(FILECREATED " 3-MAR-74 13:03:00" PUP5)
(DEFINEQ
(@
(LAMBDA (C)
C))
(A:BEING:ORDER
(LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2))))
(A:BEING:WHEN
(LAMBDA (BB)
(SETQ SUM 0)
(MAPC (GETP BB WHEN)
(FUNCTION (LAMBDA (W)
(COND
((EVAL (CAR W))
(SETQ SUM (PLUS SUM (EVAL (CADR W)))))))))
SUM))
(AD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(REMPROP X SPEC:WHY))))
(MAKEFILE (QUOTE PUP5))))
(ADD:BEING
(LAMBDA (B TREAD)
(SET B B)
(PUT B BEING T)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(PRIN1 X)
(PRIN1 " ")
(COND
((SETQ TREAD (READ))
(PUT B X TREAD))))))
(PRIN1 "*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SEMI:COMPILE B)
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER WRITE:PROGRAM PUP5FNS)
(COND
((RATOM)
(AD (LIST B)))
(T (SETQ PUP5FNS (CONS B PUP5FNS))
T)))
((RATOM)
(AD NIL))
((LENGTH PUP5FNS)))))
(ADD:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(SETQ EFFECTS:TABLE (APPEND EFFECTS:TABLE TEMPG))
(SORT EFFECTS:TABLE CAAR:ORDER)))
(ADD:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(SETQ IDEN:TABLE (APPEND IDEN:TABLE TEMPG))
(SORT IDEN:TABLE CAAR:ORDER)))
(ASSERTIONS
(LAMBDA (TEMPA)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SETQ TEMPA (CONS (LIST L (EVAL L))
TEMPA)))))
TEMPA))
(ATOMP
(LAMBDA (SOMETHING)
(ATOM SOMETHING)))
(ATTENTION:DEMONS
(LAMBDA NIL T))
(CAAR:ORDER
(LAMBDA (O1 O2)
(CAR:ORDER (CAR O1)
(CAR O2))))
(CAR:ORDER
(LAMBDA (O1 O2)
(COND
(O1 (COND
(O2 (COND
((EQUAL (CAR O1)
(CAR O2))
(CAR:ORDER (CDR O1)
(CDR O2)))
((ATOM (CAR O1))
(ALPHORDER (CAR O1)
(CAR O2)))
((ATOM (CAR O2))
NIL)
(T (CAR:ORDER (CAR O1)
(CAR O2)))))
(T NIL)))
(T T))))
(CHANGEB
(LAMBDA (B:NAME B:PART)
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(COND
((EQUAL B:PART MAIN:EFFECTS)
(REMOVE:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(REMOVE:IDEN B:NAME)))
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
(COND
((NULL TEMP)
(REMPROP B:NAME B:PART))
((EQUAL B:PART MAIN:EFFECTS)
(ADD:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(ADD:IDEN B:NAME)))
T))
(CHANGEP
(LAMBDA (P)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ X (GETP B P))
(PRINT B)
(COND
((ATOM X)
(PRIN1 "SORRY, PART IS NIL. NEW PART ....... ")
(SETQ X (READ)))
(T (EDITV X)))
(PUT B P X))))))
(CLASS
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(COLON:BACK
(LAMBDA (LL)
(SETQ MM (CAR LL))
(SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E)))))
(SETQ LL (CONS MM LL))
(PACK LL)))
(COLON:BREAK
(LAMBDA (E)
(PROG (UP RP)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL (COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP))))
(COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP)))))
(SETQ UP (CDR UP))
(GO LL))))
(COMMENT
(NLAMBDA FORM
(CONS COMMENT (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(CSORT
(NLAMBDA X
(MAPC X (FUNCTION (LAMBDA (L)
(SET L (SORT (COPY (EVAL L)))))))))
(DEFERRAL:DEMON
(LAMBDA NIL
(MAPCAR UNDEFERRED:DECISION:LIST DEFER:DECISION)
T))
(DETERMINE:ARG2:VALUE
(LAMBDA (CHOICE ENT2)
(SETQ ARG2 UNKNOWN)
(SETQ ENT2 (CADDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST)))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE))
TOL)
(SETQ ARG2 ANY1))))))
(COND
((EQUAL ARG2 UNKNOWN)
(SETQ ARG2 ENT2))
(ARG2))))
(DETERMINE:ARG3:VALUE
(LAMBDA (CHOICE ENT2)
(SETQ ARG3 UNKNOWN)
(SETQ ENT2 (CADDDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST)))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE))
TOL)
(SETQ ARG3 ANY1))))))
(COND
((EQUAL ARG3 UNKNOWN)
(SETQ ARG3 ENT2))
(ARG3))))
(DETERMINE:ARG:VALUE
(LAMBDA (CHOICE ENT2)
(SETQ ARG1 UNKNOWN)
(SETQ ENT2 (CADR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST)))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE))
TOL)
(SETQ ARG1 ANY1))))))
(COND
((EQUAL ARG1 UNKNOWN)
(SETQ ARG1 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG1))
(SETQ HOLD:ANY2 UNKNOWN)
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG1)
((EQUAL ARG1 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG1))))
(DIMENSION1
(LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION2
(LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION3
(LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR)))))
(DISK:DUMP
(LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE)))
(DOT:PROD
(LAMBDA (L1 L2)
(COND
(L1 (PLUS (COND
(L2 (TIMES (CAR L1)
(CAR L2)))
(T 0.0))
(DOT:PROD (CDR L1)
(CDR L2))))
(T 0))))
(DUMMIES
(LAMBDA (NDUM)
(COND
((ZEROP NDUM)
NIL)
(T (CONS (COLON:BACK (LIST DUMMY:ARGUMENT NDUM))
(DUMMIES (SUB1 NDUM)))))))
(DUMP:BEING
(LAMBDA (B)
(PRIN1 "************************* ")
(PRINT B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(COND
((SETQ X2 (GETP B X))
(PRINT X)
(PP X2)
(TERPRI))))))
(QUOTE FINISHED)))
(ENTER
(LAMBDA (EXPERTISE)
(SETQ NEW:F:NUMBER 0)
(SETQ RESULT:COUNTER 0)
(SETQ LABEL:COUNTER 0)
(MAPC TRIVIAL:BEING:LIST (FUNCTION (LAMBDA (TB)
(PUT TB BEING T)
(SET TB TB))))
(SETQ IS:BEING:LIST SET:OF:BEINGS)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(START EXPERTISE)
(PRIN1 "
EXITING FROM THE SYSTEM.
")))
(FAD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (COPY (APPEND PUP5FNS L IS:BEING:LIST))))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (PRIN1 " FULL PUP FILE; USE MAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS)))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS IS:BEING:LIST))
T))
(FAST:BEING:COMPLEX
(LAMBDA (B)
(COND
((NOT (ATOM B))
(SETQ B (CAR B))))
(COND
((GETP B COMPLEXITY:VECTOR)
(DOT:PROD (QUOTE (.01 .06 .03 0.0 .9))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL)))
(T 1.0))))
(FIRST:FEW
(LAMBDA (L)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N))))
(FIRSTN
(LAMBDA (N L)
(PROG (TTT)
LLL (COND
((ZEROP N)
(RETURN TTT)))
(SETQ N (SUB1 N))
(SETQ TTT (NCONC1 TTT (CAR L)))
(SETQ L (CDR L))
(GO LLL))))
(FLATTEN
(LAMBDA (L)
(COND
((ATOM L)
(LIST L))
(T (APPEND (FLATTEN (CAR L))
(FLATTEN (CDR L)))))))
(FOREVER
(LAMBDA NIL NIL))
(FORGETFUL:USER:DEMON
(LAMBDA NIL
(SETQ AWARE:USER:LIST (SETUNION FRINGE:CONCIOUS:LIST (LIST (CAR AWARE:USER:LIST))))
T))
(FRINGE:OF:CONCIOUSNESS:DEMON
(LAMBDA NIL T))
(GETCODE
(LAMBDA (F1 FNAME LEVEL C1 C2 OLDNAME:TAG)
(COND
((ATOM F1)
(COND
((MEMBER F1 PRIMITIVE:PROGRAMS:LIST)
F1)
((MEMBER F1 TRIVIAL:BEING:LIST)
(SETQ FARGS (NCONC1 FARGS F1))
(PRIN1 (CONCAT
"
HERE IN GETCODE WE ARE USING THE TRIVIAL:BEING:LIST OPTION. THE
VALUES OF F1 AND ARG:LIST ARE " F1 ARG:LIST))
F1)
((MEMBER F1 ARG:LIST)
(SETQ FARGS (NCONC1 FARGS F1))
F1)
((NOT (GETP F1 BEING))
(COND
((OR (NOT (MINUSP LEVEL))
(AND (MATCH (TUPLE A R G ANY1)
(UNPACK F1))))
(SETQ FARGS (NCONC1 FARGS F1))))
F1)
(T (SETQ F1BACKUP F1)
(GET:NAME (LIST VECTOR F1)
(VECTOR CNAME))
(COND
((NULL OLDNAME:TAG)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR F1BACKUP)
IS UNKNOWN BUT USED IN (@ FNAME))
TYPE:OF:LIST))
(SETQ UNDEFINED:SECTION:LIST (SETUNION UNDEFINED:SECTION:LIST (LIST (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR
F1BACKUP)))))
)
(T (SETQ OLDNAME:TAG NIL)))
CNAME)))
((EVAL (GETP (CAR F1)
FORM:CHANGING)))
((MEMBER (CAR F1)
(QUOTE (COMMENT QUOTE NLAMBDA * STRUCTURE)))
F1)
((MATCH (TUPLE SETQ ANY1 ANY2)
F1)
(SETQ C1 ANY2)
(SETQ C11 ANY1)
(COND
((OR (NUMBERP (CAR (LAST (COLON:BREAK ANY1))))
(MATCH (TUPLE A R G FRAG1)
(UNPACK ANY1))
(MEMBER ANY1 ARG:LIST)
(MEMBER ANY1 PRIMITIVE:PROGRAMS:LIST)
(MATCH (TUPLE E V A L : A R G FRAG1)
(UNPACK ANY1)))
(SETQ CNAME ANY1))
(T (GET:NAME (LIST VECTOR ANY1)
(VECTOR CNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR C11)
IS USED IN (VECTOR ASSIGNMENT STATEMENT IN (@ FNAME)))
TYPE:OF:LIST))
(TUPLE SETQ (@ CNAME)
(GETCODE C1 FNAME (SUB1 LEVEL))))
(T (CONS (PROG1 (SETQ C1 (GETCODE (CAR F1)
FNAME
(SUB1 LEVEL)))
(COND
((AND (ATOM C1)
(NUMBERP (CAR (LAST (COLON:BREAK C1)))))
(SETQ FN:CALL:LIST (CONS (INVECTOR (CONS C1 (CDR F1)))
FN:CALL:LIST)))))
(PROG1 (SETQ C2 (GETCODE (CDR F1)
(COND
((MEMBER C1 PRIMITIVE:PROGRAMS:LIST)
FNAME)
(T C1))
(SUB1 LEVEL)))
(COND
((AND (ATOM C1)
(NUMBERP (CAR (LAST (COLON:BREAK C1)))))
(SETQ TRUE:FN:CALL:LIST (CONS (OUTVECTOR (CONS C1 C2))
TRUE:FN:CALL:LIST))))))))))
(HIGHLY:STRUCTURED
(LAMBDA (B)
(EQUAL (CAR (GETP B META:CODE))
STRUCTURE)))
(IDIOM:DEMON
(LAMBDA NIL T))
(INCOMMENT
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
COMMENT)
(MAPCAR L INCOMMENT))
(T (CONS COMMENT (MAPCAR L INCOMMENT))))))
(INFER:INSIDE
(LAMBDA (SUBROUTINE FN:NAME)
T))
(INFERENCE:DEMONS
(LAMBDA NIL T))
(INITIALS
(LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E)))))))
(INSTANTIATE
(LAMBDA (FORM)
(COND
((ATOM FORM)
FORM)
((EQUAL (CAR FORM)
$)
(EVAL (CADR FORM)))
(T (CONS (INSTANTIATE (CAR FORM))
(INSTANTIATE (CDR FORM)))))))
(INTUPLE
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
TUPLE)
(MAPCAR L INTUPLE))
(T (CONS TUPLE (MAPCAR L INTUPLE))))))
(INVECTOR
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
VECTOR)
(MAPCAR L INVECTOR))
(T (CONS VECTOR (MAPCAR L INVECTOR))))))
(IRRELEVANT
(LAMBDA (L)
(NOT (EVAL (CDR L)))))
(LEARN:BY:EXAMPLE
(LAMBDA (ARGVECTOR)
(PRIN1 "
LEARN BY EXAMPLE IS NOT IN YET; PLEASE TYPE IN WHAT IT SHOULD RETURN.
ITS ARGUMENT VECTOR IS ")
(PRIN1 ARGVECTOR)
(PRIN1 " . OK, TYPE IN ANSWER:
USER: ")
(INVECTOR (READ))))
(LONG:NAME:DEMON
(LAMBDA (MLIST UPT LNAME)
(SETQ MLIST (MAPCONC (FLATTEN (APPEND CODING:WARNING:LIST TYPE:OF:LIST))
(FUNCTION (LAMBDA (SS)
(COND
((AND (GREATERP (LENGTH (SETQ UPT (UNPACK SS)))
50)
(NUMBERP (CAR (LAST UPT))))
(LIST SS)))))))
(MAPC MLIST (FUNCTION (LAMBDA (TOL)
(SETQQ LNAME LNAME)
(GET:NAME (VECTOR (COLON:BACK (REVERSE (CDR (REVERSE (COLON:BREAK TOL))))))
(VECTOR LNAME))
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (AL)
(SET AL (DSUBST LNAME TOL (EVAL AL))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND
((GETP B META:CODE)
(PUT B META:CODE (DSUBST LNAME TOL (GETP B META:CODE)))))))))))))
(LUMP:ASSERTIONS
(LAMBDA (L TEMPL TEMPL2)
(SETQ TEMPL NIL)
(SETQ L (ASSERTIONS))
(MAPC L (FUNCTION (LAMBDA (L1)
(SETQ TEMPL (APPEND TEMPL (CADR L1))))))
(SETQ TEMPL2 (COPY TEMPL))
(SETQ TEMPL2 (INTERSECTION TEMPL2 TEMPL2))
(SORT TEMPL2)))
(MAD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS SET:OF:BEINGS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS)))))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (APPEND SET:OF:BEINGS PUP5FNS))
T))
(MAIN:WORDS
(LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS)))
(MAKE:SPECIFIC
(LAMBDA (A)
(SETQ IS:SPECIFIC:LIST (CONS A IS:SPECIFIC:LIST))))
(MATCH
(LAMBDA (A B LD)
(SETQ LD (ADD1 (DIFFERENCE (LENGTH B)
(LENGTH A))))
(SETQ MATCH:RESULT T)
(COND
((MINUSP LD)
(SETQ MATCH:RESULT NIL))
(T (MAPC A (FUNCTION (LAMBDA (A1)
(COND
((MEMB A1 (QUOTE (ANY1 ANY2 ANY3)))
(SET A1 (CAR B))
(SETQ B (CDR B)))
((MEMB A1 (QUOTE (FRAG1 FRAG2)))
(SET A1 (FIRSTN LD B))
(SETQ B (NTH B (ADD1 LD))))
((EQUAL A1 (CAR B))
(SETQ B (CDR B)))
((LISTP A1)
(SETQ MATCH:RESULT (AND MATCH:RESULT (MATCH A1 (CAR B))))
(SETQ B (CDR B)))
(T (SETQ MATCH:RESULT NIL))))))))
(AND (NULL B)
MATCH:RESULT)))
(MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ MINNUM UNKNOWN)
(CADAR (CDDDDR MIN))))))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(COND
((OR (LESSP (SETQ TV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ NEWNUM UNKNOWN)
(CADAR (CDDDDR ELE))))))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
MIN))
(MOST:GENERAL
(LAMBDA (L)
(CAR L)))
(MOVE:BEING
(LAMBDA (B:OLD B)
(SET B B)
(PUT B BEING T)
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(PUT B P (COPY (GETP B:OLD P))))))
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER ENCODE PUP5FNS)
(SETQ PUP5FNS (CONS B PUP5FNS))))
(SEMI:COMPILE B)))
(MULT:INTERSECTION
(LAMBDA (L)
(COND
((CDDR L)
(SETINTERSECTION (CAR L)
(MULT:INTERSECTION (CDR L))))
(T (SETINTERSECTION (CAR L)
(CADR L))))))
(NEW:IDEN
(LAMBDA NIL
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(PUT B IDEN (LIST (LIST (QUOTE AND)
(LIST (QUOTE EQUAL)
(QUOTE (CAR LI))
B)
(LIST (QUOTE EQUAL)
(QUOTE (LENGTH (CDR LI)))
(LENGTH (GETP B EXPLICIT:ARGS))))
(LIST (QUOTE LIST)
B
(LIST TRANSLATE (QUOTE (CADR LI)))))))))))
(NEW:LEVEL
(LAMBDA (EXPERTISE)
(PROG (NEWL)
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L (SETQ NEWL (COND
((NUMBERP EXPERTISE))
((RATOM))))
(SETQ EXPERTISE NIL)
(SETQ PERMANENT:USER:INTERRUPT:DEMONS (SELECTQ NEWL
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS))))
(NULLIFY
(LAMBDA (L)
(SET (CAR L)
NIL)
(COND
((CDR L)
(NULLIFY (CDR L))))))
(OPPOSITE
(LAMBDA (WORD)
(SELECTQ WORD
(RELEVANT (QUOTE IRRELEVANT))
(IRRELEVANT (QUOTE RELEVANT))
(STATIC (QUOTE DYNAMIC))
(DYNAMIC (QUOTE STATIC))
(LE (QUOTE GT))
(GT (QUOTE LE))
(LT (QUOTE GE))
(GE (QUOTE LT))
(HAPPY (QUOTE SAD))
(SAD (QUOTE HAPPY))
(QUOTE TEMPORARILY))))
(OUTNIL
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
NIL)
(OUTNIL (CDR S)))
(T (CONS (OUTNIL (CAR S))
(OUTNIL (CDR S)))))))
(OUTQUOTE
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
(QUOTE QUOTE))
(CONS TUPLE (OUTQUOTE (CADR S))))
(T (CONS (OUTQUOTE (CAR S))
(OUTQUOTE (CDR S)))))))
(OUTTUPLE
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
TUPLE)
(OUTTUPLE (CDR S)))
(T (CONS (OUTTUPLE (CAR S))
(OUTTUPLE (CDR S)))))))
(OUTVECTOR
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
VECTOR)
(OUTVECTOR (CDR S)))
(T (CONS (OUTVECTOR (CAR S))
(OUTVECTOR (CDR S)))))))
(PERMIT:DETAILED:DECISION
(LAMBDA NIL
(TERPRI)
(PRIN1 "SHOULD I DISCUSS RAMIFICATIONS?")
(COND
((EQUAL (RATOM)
YES)
(PRIN1 "I ASK NOW BECAUSE")
(PRIN1 (CADDDR D))
(PRIN1 " HAS THE NON-NULL VALUE ")
(PRIN1 (EVAL (CADDDR D)))
(COND
((MEMBER WHY (CADR D))
(PRIN1 "THIS, IN TURN, IS")
(PRIN1 (CDADR (MEMBER WHY (CADR D))))
(TERPRI)))
(COND
((MEMBER COMMENT (CADR D))
(PRIN1 "
ANOTHER COMMENT ABOUT THIS IS:
")
(PRINT (EVAL (CADR (MEMBER COMMENT (CADR D)))))))
(SELECTQ DTYPE
(BOOLEAN (PRIN1 " THE EFFECT OF
ANSWERING YES IS ")
(PRIN1 (COND
((APPEND (CADR (MEMBER YES:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T (CDDADR (MEMBER AFFECTS (CADR D))))))
(TERPRI)
(PRIN1 (COND
((APPEND (CADR (MEMBER NO:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T "THE EFFECT OF ANSWERING NO IS THUS NO:EFFECT"))))
(SOMEOF (PRIN1
"
WE SHALL REPEATEDLY DO SOME OF THESE ACTIONS. YOUR REPLY TELLS ME
WHICH ONE(S) ARE ACTUALLY INVOLVED IN THIS FUNCTION. YOUR ANSWER
AFFECTS ")
(PRINT (CDADR (MEMBER AFFECTS (CADR D)))))
(PROGN (PRIN1 "
YOUR REPLY AFFECTS ")
(PRINT (CDADR (MEMBER AFFECTS (CADR D))))))))))
(PERMIT:USER:INTERRUPT
(LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1 "
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (RATOM)
(Y (PROCESS:USER:INTERRUPT))
(N T)
(PROGN (PRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT)))))
(PLURAL
(LAMBDA (OBJECT)
(COND
((MATCH (TUPLE FRAG1 ANY1 OF ANY2)
(COLON:BREAK OBJECT))
(COLON:BACK (APPEND FRAG1 (LIST (PACK (LIST ANY1 (QUOTE S)))
(QUOTE OF)
ANY2))))
(T (PACK (LIST OBJECT (QUOTE S)))))))
(POP:DEMONS
(LAMBDA NIL
(SETQ CURRENT:DEMONS (CAR DEMON:STACK))
(SETQ DEMON:STACK (CDR DEMON:STACK))
T))
(PROCEDURE:INTERSECTION
(LAMBDA (P P1 YTEMP)
(SETQ P1 (CAAR P))
(COND
((MEMBER NIL (MAPCAR (CDR P)
(FUNCTION (LAMBDA (P2)
(EQUAL (CAR P2)
P1)))))
NIL)
((EQUAL P1 (QUOTE PROGN))
(SETQ YTEMP (MULT:INTERSECTION (MAPCAR P (QUOTE CDR))))
(COND
((LESSP (LENGTH YTEMP)
2)
(CAR YTEMP))
(T (CONS P1 YTEMP))))
((LESSP (LENGTH P)
2)
(CAR P))
(T NIL))))
(PROCEDURE:PULLOUT
(LAMBDA (PIECE BODY PPRESULT)
(SETQ PPRESULT (COND
((NULL PIECE)
BODY)
((EQUAL (CAR BODY)
(CAR PIECE))
(CONS (CAR BODY)
(SETDIFFERENCE (CDR BODY)
(CDR PIECE))))
(T (CONS (CAR BODY)
(SETDIFFERENCE BODY (LIST (CAR BODY)
PIECE))))))
(COND
((MATCH (TUPLE PROGN ANY1)
PPRESULT)
ANY1)
(T PPRESULT))))
(PROCEDURE:SUBSET
(LAMBDA (A1 A2)
(NOT (MEMBER NIL (MAPCAR (CDR A1)
(FUNCTION (LAMBDA (A3)
(MEMBER A3 A2))))))))
(PROCESS:USER:INTERRUPT
(LAMBDA NIL
(PROG (RESPONSE BC BC1 BC2)
(COND
((NOT EXPERTISE)
(PRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK))))
(PRIN1 " TYPE ? OR ")))
(SETQ BC (CAR BEING:STACK))
(SETQ BC1 NIL)
(SETQ BC2 (CDR BEING:STACK))
L (PRIN1 " REQUEST: ")
(SELECTQ (SETQ RESPONSE (READ))
(CH (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(? (PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
")
(PRIN1 "NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (Y)
(PRIN1 Y)
(PRIN1 " PRINT OUT ")
(PRIN1 Y)
(PRIN1 " WITH RESPECT TO CURRENT BEING
")))))
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN T))
(FAIL (RETURN NIL))
(SPEC:WHEN (PRINT (MAPCAR (GETP BC WHEN)
(FUNCTION (LAMBDA (W)
(TUPLE (CAR W)
IS
(SETQ W2 (EVAL (CAR W)))
SO WE (COND
(W2 (QUOTE DO))
(T (QUOTE DONT)))
ADD IN THE WEIGHT (CADR W) WHICH IN THE CURRENT CASE IS
(EVAL (CADR W)) ;THE
EXPLANATION IS
(EVAL (CADDR W)))))))
(PRINT (TUPLE THE FINAL WHEN VALUE IS THUS (A:BEING:WHEN BC))))
(BEING (PRINT BC))
(CONTROL:HISTORY (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(DEMONS (PRIN1 CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT DEMON:STACK))
(OLDER (SETQ BC1 (NCONC1 BC1 BC))
(SETQ BC (CAR BC2))
(SETQ BC2 (CDR BC2))
(PRINT BC))
(NEW:LEVEL (NEW:LEVEL))
(YOUNGER (SETQ BC2 (CONS BC BC2))
(SETQ BC (LAST BC1))
(SETQ BC1 (REVERSE (CDR (REVERSE BC1))))
(PRINT BC))
(OLDEST (SETQ BC (LAST BEING:STACK))
(SETQ BC1 (REVERSE (CDR (REVERSE BEING:STACK))))
(SETQ BC2 NIL)
(PRINT BC))
(YOUNGEST (SETQ BC (CAR BEING:STACK))
(SETQ BC2 (CDR BEING:STACK))
(SETQ BC1 NIL)
(PRINT BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (OUTTUPLE (GETP BC RESPONSE)))))
((MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (EVAL (GETP BC RESPONSE)))))
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (PRIN1 "
*** ERROR *** TYPE ? FOR ASSISTANCE **********
")
(GO L))))
(GO L))))
(PROGRAM:WRITING:DEMONS
(LAMBDA NIL T))
(PSYCHOLOGY:DEMON
(LAMBDA NIL T))
(PULLOUT
(LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L)))))))
(PUSH:DEMONS
(LAMBDA (NEW:DEMONS)
(SETQ NEW:DEMO (SETDIFFERENCE NEW:DEMONS CURRENT:DEMONS))
(SETQ CURRENT:DEMONS (APPEND NEW:DEMO CURRENT:DEMONS))
(SETQ DEMON:STACK (CONS CURRENT:DEMONS DEMON:STACK))))
(REINVESTIGATION:DEMON
(LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADDDR D))
(REINVESTIGATE:DECISION D))
(T NOT:TIME:YET)))))
T))
(RELEVANT
(LAMBDA (L)
(EVAL (CDR L))))
(REMOVE:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ EFFECTS:TABLE (PULLOUT E EFFECTS:TABLE)))))))
(REMOVE:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ IDEN:TABLE (PULLOUT E IDEN:TABLE)))))))
(SEMI:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (TUPLE (COND
((GETP B NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ))))
(LIST (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK))))
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS)))
(LIST (GETP B EXPLICIT:ARGS:CHECK))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(GETP B COMMENTS)
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X)))))
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
(COND
((GETP B INHIBIT:CURRENT:DEMONS)
(QUOTE ((NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(T (QUOTE ((NOT (MEMBER NIL (MAPCAR (APPEND CURRENT:DEMONS
USER:INTERRUPT:DEMONS)
(QUOTE APPLY*))))))))
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
(QUOTE ((NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(COND
((GETP B PREDICATE)
(QUOTE ((COND
(FN:VALUE)
(T FALSE)))))
(T (QUOTE (FN:VALUE)))))
(QUOTE (SETQ BEING:STACK (CDR BEING:STACK)))
(QUOTE (POP:DEMONS))))))))))
(SET:UP:EFFECTS:TABLE
(LAMBDA (TEMPTOO)
(SETQ E:TABLE NIL)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B MAIN:EFFECTS))))))
(SETQ EFFECTS:TABLE (COPY E:TABLE))
(SORT EFFECTS:TABLE CAAR:ORDER)
(LENGTH EFFECTS:TABLE)))
(SET:UP:IDEN:TABLE
(LAMBDA (TEMPTOO)
(SETQ E:TABLE FUNDAMENTAL:IDEN:TABLE)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B IDEN))))))
(SETQ IDEN:TABLE (COPY E:TABLE))
(SORT IDEN:TABLE CAAR:ORDER)
(LENGTH IDEN:TABLE)))
(SETDIFFERENCE
(LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND (COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1))))
(SETDIFFERENCE (CDR S1)
S2))))))
(SETINTERSECTION
(LAMBDA (S1 S2)
(INTERSECTION S1 S2)))
(SETUNION
(LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1)))
(SINGLETON
(LAMBDA (S)
(NULL (CDR S))))
(SIZE
(LAMBDA (STRUC)
(ADD1 (IQUOTIENT (COUNT STRUC)
2))))
(SPECIFICITY:CHECK:DEMON
(LAMBDA (ANYTHING)
(MAPC (SETDIFFERENCE PUP:WANTS:LIST IS:SPECIFIC:LIST)
MAKE:SPECIFIC)
T))
(START
(LAMBDA (EXPERTISE)
(PROG NIL
L1 (SETQ BEING:STACK NIL)
(SETQ BECAUSE (VECTOR))
(SETQ FORCE:TRANSLATE NIL)
(SETQ DEMON:STACK NIL)
(SETQ CURRENT:DEMONS NIL)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SET L NIL))))
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
(SETQ DOING:PUP:LIST (QUOTE ((COMMENT END OF STACK MARKER))))
L (SETQ PERMANENT:USER:INTERRUPT:DEMONS (SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
L3 (SERVE)
L4 (COND
(EXPERTISE (PRIN1
"
FINISHED CURRENT SERVICE; WHAT SHOULD I DO? TYPE ONE OF:
1 EXIT FROM SYSTEM
2 CONTINUE SERVING, AS BEFORE
3 CONTINUE SERVING, BUT GET A NEW USER INTERRUPT LEVEL
4 REINITIALIZE SYSTEM AND START FROM BEGINNING AGAIN
OK, GO .......... "))
(T (PRIN1 "
FINISHED SERVICE. 1 EXIT; 2 CONTINUE; 3 NEW LEVEL; 4 START OVER ")))
(SELECTQ (RATOM)
(2 (GO L3))
(3 (GO L2))
(4 (GO L1))
(1 "EXITING SYSTEM")
(PRIN1 "NO, NO!!!!! ")
(GO L4)))))
(STRUCTURE
(NLAMBDA FORM
(CONS STRUCTURE FORM)))
(STRUCTURE:COMPATIBLE
(LAMBDA (B1 B2)
(COND
((AND (HIGHLY:STRUCTURED B1)
(HIGHLY:STRUCTURED B2)
(EQUAL (LENGTH (GETP B1 META:CODE))
(LENGTH (GETP B2 META:CODE))
(NOT (MEMBER NIL (MAP2CAR (GETP B1 META:CODE)
(GETP B2 META:CODE)
(FUNCTION (LAMBDA (P1 P2)
(EQUAL (CADR P1)
(CADR P2))))))))))
(T NIL))))
(STRUCTURE:INDUCING:DEMON
(LAMBDA (OBJECT PIECES)
(SETQ STAG NIL)
(COND
((GETP OBJECT BEING)
SORRY:NOT:IN:YET)
((NULL OBJECT)
(TERPRI)
(PRINT (TUPLE IF SOME SORT OF (PACK (TUPLE KNOWN:LIST:OF:(PLURAL ARG1))) EXISTED,
THEN I WOULD RECOMMEND THAT IT BE STRUCTURED INTO (LENGTH PIECES) PIECES, NAMED (@ PIECES) .IF
SUCH A LIST IS LATER CREATED, THIS COMMENT WILL STILL APPLY, BUT A GREAT DEAL OF CODE MAY
HAVE
TO BE CHANGED.))
(TERPRI))
((PROGN (TERPRI)
(PRINT (TUPLE I RECOMMEND THAT (@ OBJECT)
BE STRUCTURED INTO (TUPLE AT LEAST ALONG ONE DIMENSION)
THESE
(LENGTH PIECES)
PIECES:(@ PIECES)
.PLEASE TYPE BACK YES, NO, OR UNSURE.))
(PRIN1 "
USER: ")
(MEMBER (RATOM)
(QUOTE (Y YES T UNSURE MAYBE))))
(PROG (CODE BNAME)
(SETQ CODE (APPEND (STRUCTURE)
(MAPCAR PIECES (FUNCTION (LAMBDA (PIECE)
(TUPLE (@ PIECE)
SET OF (PLURAL ARG1)))))))
(SETQ BNAME LIST:STRUCTURE)
(SATISFY (VECTOR IS BEING OBJECT)))
(SETQ CODING:WARNING:LIST (CONS (VECTOR IN ALL CODE GENERATED, (@ OBJECT) SHOULD BE REPLACED
BY (CONS (QUOTE APPEND)
PIECES))
CODING:WARNING:LIST))
(SETQ STAG T))
(T (PRIN1 "
OK, SO WE JUST GO ON NOW.
")))))
(SUBSTITUTE
(LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (COPY (EVAL LIST:STRUCTURE))))))
(TEMPORARILY
(LAMBDA (L)
(EVAL (CDR L))))
(TRACE:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (QUOTE (LAMBDA))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ BEING:FLAG DEMON:FLAG))))
(LIST (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK)))))
(LIST (LIST (QUOTE PRINT)
(GETP B EXPLICIT:ARGS:CHECK)))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X)))))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X))))))
(QUOTE ((PRINT "COMMENTS BEGINNING")))
(GETP B COMMENTS)
(QUOTE ((PRINT "COMMENTS ENDING")))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE))))
(QUOTE ((PRIN1 "NOT1 ")))
(QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE))))
(QUOTE ((PRIN1 "NOT2 ")))
(QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR FINAL:CO:REQ SATISFY))))))
(QUOTE ((PRINT (POP:DEMONS))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X)))))
(QUOTE ((SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR (PRINT BEING:STACK)))))
(COND
((GETP B PREDICATE)
(QUOTE ((PRINT (COND
(FN:VALUE)
(T FALSE))))))
(T (QUOTE ((PRINT FN:VALUE))))))
(QUOTE (PRINT (TUPLE BEING:FLAG (@ BEING:FLAG)
DEMON:FLAG
(@ DEMON:FLAG))))
(QUOTE (PRINT (COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS)))))))))))))
(TRY:TO:SATISFY
(LAMBDA (SUBGOAL)
(COND
((SATISFY SUBGOAL)
T)
(T (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ))))))
(TUPLE
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(USER:INTERRUPT:AT:ADAPTING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ADAPT:PRECONCEIVED:FUNCTION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:CODING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ENCODE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:CODING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:DEBUG
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
CLARIFY:IMPROBABLE:SITUATION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:END
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
OPTIMIZE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:END USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:PHASES
(LAMBDA (S:EXP)
(COND
((MEMBER (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES))
(PERMIT:USER:INTERRUPT)))))
(VECTOR
(NLAMBDA FORM
(CONS VECTOR (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(VECTOR:AVERAGE
(LAMBDA (L)
(LIST .8 .8 .8 .8 .1)))
(WHEN:VALUE
(LAMBDA (B:CALL)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
(MAP2C EXP:A (CDR B:CALL)
(FUNCTION (LAMBDA (NEWARG OLDARG)
(SET NEWARG OLDARG))))
(COND
((EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
(A:BEING:WHEN (CAR B:CALL)))
(T -1000))))
(Z@
(LAMBDA (X)
X))
)
(LISPXPRINT (QUOTE PUP5FNS)
T)
(RPAQQ PUP5FNS
(@ A:BEING:ORDER A:BEING:WHEN AD ADD:BEING ADD:EFFECTS ADD:IDEN ASSERTIONS ATOMP ATTENTION:DEMONS CAAR:ORDER
CAR:ORDER CHANGEB CHANGEP CLASS COLON:BACK COLON:BREAK COMMENT CSORT DEFERRAL:DEMON DETERMINE:ARG2:VALUE
DETERMINE:ARG3:VALUE DETERMINE:ARG:VALUE DIMENSION1 DIMENSION2 DIMENSION3 DISK:DUMP DOT:PROD DUMMIES
DUMP:BEING ENTER FAD FAST:BEING:COMPLEX FIRST:FEW FIRSTN FLATTEN FOREVER FORGETFUL:USER:DEMON
FRINGE:OF:CONCIOUSNESS:DEMON GETCODE HIGHLY:STRUCTURED IDIOM:DEMON INCOMMENT INFER:INSIDE INFERENCE:DEMONS
INITIALS INSTANTIATE INTUPLE INVECTOR IRRELEVANT LEARN:BY:EXAMPLE LONG:NAME:DEMON LUMP:ASSERTIONS MAD
MAIN:WORDS MAKE:SPECIFIC MATCH MINIMUM MOST:GENERAL MOVE:BEING MULT:INTERSECTION NEW:IDEN NEW:LEVEL NULLIFY
OPPOSITE OUTNIL OUTQUOTE OUTTUPLE OUTVECTOR PERMIT:DETAILED:DECISION PERMIT:USER:INTERRUPT PLURAL
POP:DEMONS PROCEDURE:INTERSECTION PROCEDURE:PULLOUT PROCEDURE:SUBSET PROCESS:USER:INTERRUPT
PROGRAM:WRITING:DEMONS PSYCHOLOGY:DEMON PULLOUT PUSH:DEMONS REINVESTIGATION:DEMON RELEVANT REMOVE:EFFECTS
REMOVE:IDEN SEMI:COMPILE SET:UP:EFFECTS:TABLE SET:UP:IDEN:TABLE SETDIFFERENCE SETINTERSECTION SETUNION
SINGLETON SIZE SPECIFICITY:CHECK:DEMON START STRUCTURE STRUCTURE:COMPATIBLE STRUCTURE:INDUCING:DEMON
SUBSTITUTE TEMPORARILY TRACE:COMPILE TRY:TO:SATISFY TUPLE USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END USER:INTERRUPT:AT:PHASES VECTOR
VECTOR:AVERAGE WHEN:VALUE Z@))
(LISPXPRINT (QUOTE PUP5VARS)
T)
(RPAQQ PUP5VARS
($ AFFECTS:ALL AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE WHEN:ALL:DEFER:DECISION:KNOWLEDGE
BOOLEAN:DEFER:DECISION:KNOWLEDGE WHEN:ALL DICHOTOMY:DEFER:DECISION:KNOWLEDGE
ADAPTATION:DEFER:DECISION:KNOWLEDGE ALTERNATIVES:DEFER:DECISION:KNOWLEDGE AND:LOOP:TERMINATION:KNOWLEDGE
PREDICATE:RESOLVE:DECISION:KNOWLEDGE PREDICATE:DEFER:DECISION:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
TRIVIAL:BEING:LIST RESULT:COUNTER BOTH:RESULTS YES:RESULTS NO:RESULTS SET:OF POSSIBLE FLOW:ASSIGNMENT
DUMMY:ARGUMENT ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE EQUAL ISNT DOESNT EQUALS IS DOES RESULTS
DICHOTOMY:DEFER:DECISION:KNOWLEDGE DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE ADJECTIVES
DEFINITION:RESOLVE:DECISION:KNOWLEDGE DEFINITION:DEFER:DECISION:KNOWLEDGE UNKNOWN COMMENT GO LABEL:COUNTER
KNOWLEDGE BOOLEAN:RESOLVE:DECISION:KNOWLEDGE SOMEOF:RESOLVE:DECISION:KNOWLEDGE YES ASSERT:LISTS
SOMEOF:DEFER:DECISION:KNOWLEDGE IS:BEING:LIST BEING BREAKUP:LIST UNTIL FUNDAMENTAL:IDEN:TABLE SINCE FOREVER
PRIMITIVE:PROGRAMS:LIST PRIMITIVE:VARS:LIST Y N NOT:TIME:YET CALL COMPILABLE:BEING:PARTS EFFECTS:TABLE EVAL
PARTS EVAL:BEING:PARTS FALSE IDEN:TABLE INFERIOR MINOR:WORDS ING NAME NON:EVAL:BEING:PARTS NON:EXECUTABLE
PERMANENT:KNOWN:NAMES PROGRAM:WRITING:PHASES SET:OF:BEING:PARTS SET:OF:BEINGS SUPERIOR
(COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
(P (MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(WIDEPAPER T))
(P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION "))))
(RPAQQ $ $)
(RPAQQ AFFECTS:ALL AFFECTS:ALL)
(RPAQQ AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR THE BASIC STRUCTURE OF FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE AMOUNT OF EFFORT ANY1 SHOULD SPEND ON FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR HOW ANY1 STORES FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF STORING)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE ANY2 ALGORITHM)
(TUPLE MEMBER NIL (TUPLE MAPCAR DOING:PUP:LIST (TUPLE FUNCTION (TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT
(TUPLE MATCH
(VECTOR ANY1 TYPE OF
(LIST VECTOR
ANY2))
PD)))))))
((VECTOR CODE INVOLVING ANY1)
(TUPLE MEMBER NIL (TUPLE MAPCAR (TUPLE FLATTEN DOING:PUP:LIST)
(TUPLE FUNCTION
(TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT (TUPLE OR (TUPLE EQUAL (@ ANY1)
PD)
(TUPLE MEMBER (@ ANY1)
(TUPLE COLON:BREAK PD))
(TUPLE EQUAL (@ ANY1)
(TUPLE COLON:BACK
(TUPLE REVERSE
(TUPLE CDR
(TUPLE REVERSE
(TUPLE
COLON:BREAK PD))
)))))))))))
((VECTOR WHAT INFORMATION ANY1 MAY USE TO ANY2 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY2 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR ANY1 DETAILS)
(TUPLE MEMBER (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
DOING:PUP:LIST))))
(RPAQQ WHEN:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR BEFORE DECIDING FIRMLY HOW TO ANY1 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR BEFORE ANY FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(MORE)
(OTHER))))
(TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST))
(FRAG2 (TUPLE MEMBER T (TUPLE MAPCAR (TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
(TUPLE FUNCTION (TUPLE LAMBDA (TUPLE X)
(TUPLE AND (TUPLE OR (TUPLE ATOM X)
(TUPLE SETQ X
(TUPLE CADR
(TUPLE CADDDR X)))
)
(TUPLE OR (TUPLE EQUAL FRAG2 (TUPLE LIST X)
)
(TUPLE SETINTERSECTION
(INTUPLE FRAG2)
(TUPLE GETP X
GENERALIZATIONS)))))))
))))
((VECTOR AFTER ALL FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(OTHER)
(THE))))
(TUPLE NULL UNDEFINED:SECTION:LIST))
(T (TUPLE NOT (TUPLE MEMBER (TUPLE CAR FRAG2)
(TUPLE FLATTEN UNDEFINED:SECTION:LIST))))))))
(RPAQQ BOOLEAN:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ WHEN:ALL WHEN:ALL)
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ADAPTATION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ALTERNATIVES:DEFER:DECISION:KNOWLEDGE ((COND ((AND (NOT (MEMBER NIL (MAPCAR (SETQ C (CDADR DEC))
(FUNCTION (LAMBDA (D)
(GETP D BEING))))
))
(SETQ PROC (INVECTOR (PROCEDURE:INTERSECTION
(MAPCAR C (FUNCTION (LAMBDA
(D)
(GETP D
META:CODE)))))
)))
(COND ((EQUAL TASK (INVECTOR (LAST DEC)))
(SETQ TNAME TASK:NAME))
(T (GET:NAME (INVECTOR (LAST DEC))
(VECTOR TNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ TNAME)
TYPE OF (LAST DEC)
IS
(VECTOR TEMPORARILY
(@ PROC)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (@ TNAME)
TYPE OF
(INVECTOR
(LAST DEC)))
ENCODABLE:SECTION:LIST))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION (SETDIFFERENCE (COND ((LESSP (LENGTH PROC)
3)
(LIST PROC))
(T PROC))
ABLE:PUP:LIST)
UNDEFINED:SECTION:LIST))
(TUPLE PROCEDURE:SUBSET (@ PROC)
ABLE:PUP:LIST))
(T NIL))))
(RPAQQ AND:LOOP:TERMINATION:KNOWLEDGE (SET RESULT:PLACE
(APPEND (EVAL RESULT:PLACE)
(MAPCONC (CDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(FUNCTION
(LAMBDA
(FUNC)
(COND
((NOT (NUMBERP (CAR (LAST (COLON:BREAK
(CAR FUNC))))))
NIL)
((SETQ INTSEC (INTERSECTION (COPY
DISTINGUISHED:ARG:LIST)
(CDR FUNC)))
(LIST (LIST (CAR FUNC)
(SASSOC (CAR INTSEC)
DISTINGUISHED:INFO:LIST)
T
(VECTOR T NIL))))
(T (LIST (LIST (CAR FUNC)
T))))))))))
(RPAQQ PREDICATE:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ F:CALL (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(SETQ OUTER:FN (CAR (LAST F:CALL)))
(SETQ RESULT:PLACE (CADR (MEMBER RESULTS (CADR D))))
(SETQ IS:DONE (SASSOC (CADR CHOICE)
(EVAL RESULT:PLACE)))
(COND ((EVAL (CADR IS:DONE))
(PRIN1 "
AHA!! I'VE RESOLVED THIS PREDICATE-GETTING DECISION MYSELF.
"))
(T (PRIN1 "
PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ")
(PRIN1 (CADR (MEMBER PREDICATE (CADR D))))
(PRIN1 " AND IS FALSE OTHERWISE.
")
(PERMIT:DETAILED:DECISION)
(PRIN1 "
USER: ")
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (READ))
T)))
(SETQ A:COUNT 0)
(SETQ TFN (APPLY* (OUTVECTOR (CADR (MEMBER HOW (CADR D))))
RESPONSE))
(COND ((MATCH (TUPLE DO UNTIL (TUPLE FORSOME ANY1 IN ANY2 FRAG1))
RESPONSE)
(SETQ DISTINGUISHED:ARG:LIST (CONS ANY2 DISTINGUISHED:ARG:LIST))
(SETQ DISTINGUISHED:INFO:LIST (CONS (LIST ANY2 (CADDR RESPONSE))
DISTINGUISHED:INFO:LIST))
(SETQ MEMBER:OF:LIST (CONS (LIST ANY1 ANY2)
MEMBER:OF:LIST))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (LIST VECTOR TFN)
(MAPCAR (CDR F:CALL)
(FUNCTION (LAMBDA
(DUMMY:ARG)
(PACK (TUPLE ARG (SETQ
A:COUNT
(ADD1 A:COUNT))))))
)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SETQ BRESULT (COLON:BREAK RESULT:PLACE))
(EVAL (EVAL (COLON:BACK (LIST TFN (CAR BRESULT)
(CADR BRESULT)
(QUOTE KNOWLEDGE)))))))))
(RPAQQ PREDICATE:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ APPLIED:SO:AS:TO:KEEP APPLIED:SO:AS:TO:KEEP)
(RPAQQ TRIVIAL:BEING:LIST (IN DO))
(RPAQQ RESULT:COUNTER 1)
(RPAQQ BOTH:RESULTS BOTH:RESULTS)
(RPAQQ YES:RESULTS YES:RESULTS)
(RPAQQ NO:RESULTS NO:RESULTS)
(RPAQQ SET:OF SET:OF)
(RPAQQ POSSIBLE POSSIBLE)
(RPAQQ FLOW:ASSIGNMENT (COMMENT HER IS THE FLOW ASSIGNMENT, WHICH SHOULD ACTUALLY BE SET BY THE FLOW:PRECEDED ROUTINE)
)
(RPAQQ DUMMY:ARGUMENT DUMMY:ARGUMENT)
(RPAQQ ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE NIL)
(RPAQQ EQUAL EQUAL)
(RPAQQ ISNT ISNT)
(RPAQQ DOESNT DOESNT)
(RPAQQ EQUALS EQUALS)
(RPAQQ IS IS)
(RPAQQ DOES DOES)
(RPAQQ RESULTS RESULTS)
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE (PROGN (SETQ ENT1 (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(SETQ ENT2 (CADR ENT1))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(LIST VECTOR
ENT2)
IS ANY2 AND
IS USED IN
(CADR CHOICE))
TOL)
(SETQ ARG1 ANY1))))))
(PRINT (TUPLE ABOVE, ARG1 REFERS TO (@ ARG1)))
(COND ((SETQ TRESULT (NLSETQ (EVAL (EVAL (CADDR (CADR D))))))
(SETQ TRESULT (CAR TRESULT))
(PRIN1
"
AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
USER CHANNEL AFTER ALL!!!
"))
(T (PRIN1 (CONCAT
"
SINCE THE DECISION IS DICHOTOMOUS, TYPE A 1 OR A 2
1 MEANS THAT " (CADR (CADDR (CADR D)))
" IS CORRECT.
2 MEANS THAT "
(CADDR (CADDR (CADR D)))
" IS CORRECT.
USER: "))
(SETQ TRESULT (EQUAL (RATOM)
1))))
(SETQ NEWPIECE (CDADR (MEMBER RESULTS (CADR D))))
(SETQ NEWPIECE (COND (TRESULT (CAR NEWPIECE))
(T (CADR NEWPIECE))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF
(INVECTOR (LAST (CADR D)))
IS
(INVECTOR (EVAL NEWPIECE)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
(RPAQQ ADJECTIVES (STATIC DYNAMIC HARD SOFT EASY SIMPLE COMPLEX BIG LITTLE SMALL LARGE))
(RPAQQ DEFINITION:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ DEFINED:OBJECT (CAR (LAST (CDADR D))))
(COND ((NOT (MEMBER NIL (MAPCAR UNDEFINED:SECTION:LIST (FUNCTION
(LAMBDA (US1)
(NOT (COND ((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR
DEFINED:OBJECT)
FRAG1)
US1)
(SETQ HOLD:ANY1 ANY1)
(SETQ HOLD:FRAG1 FRAG1)
T))))))))
(SETQ HOLD:ANY1 DEFINED:OBJECT)
(SETQ HOLD:FRAG1 NIL)))
(PRIN1 "SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
TYPE IN THE DEFINITION OF ")
(PRIN1 HOLD:ANY1)
(COND ((AND (SETQ TCALL (SASSOC HOLD:ANY1 (OUTVECTOR FN:CALL:LIST)))
(GETP DEFINED:OBJECT PREDICATE))
(PRIN1 (CONCAT
"
SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
LOGICAL EXPRESSION, WHICH IS TRUE IF " (CADR TCALL)
" IS OF
THE "
(CDADDR TCALL)
" TYPE, AND SHOULD BE FALSE IF IT ISNT OF
THAT TYPE.
"))))
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "USER: ")
(SETQ NEW:INFO:LIST (CONS (VECTOR DEFINE (@ HOLD:ANY1)
AS
(INVECTOR (READ)))
NEW:INFO:LIST))))
(RPAQQ DEFINITION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ UNKNOWN UNKNOWN)
(RPAQQ COMMENT COMMENT)
(RPAQQ GO GO)
(RPAQQ LABEL:COUNTER 2)
(RPAQQ KNOWLEDGE KNOWLEDGE)
(RPAQQ BOOLEAN:RESOLVE:DECISION:KNOWLEDGE (PROGN (PRIN1 "SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "NOW TYPE YOUR ANSWER: ")
(MAPC (CADR (MEMBER (COLON:BACK (TUPLE (RATOM)
RESULTS))
(CADR D)))
(QUOTE EVAL))
(MAPC (CADR (MEMBER BOTH:RESULTS (CADR D)))
(QUOTE EVAL))
(PRIN1 "
OK, READY TO MOVE ON NOW.
")))
(RPAQQ SOMEOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PRIN1 "SINCE THE DECISION IS SOME:OF, TYPE ANY NON-NULL SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PRINT (LIST L1 (QUOTE ....)
D1)))))
(PRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "USER: ")
(SETQ IN:SET (READ))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(SETQ PROC (PROCEDURE:INTERSECTION (MAPCAR IN:SET:TRANS (FUNCTION (LAMBDA (B)
(MAPC (GETP B COMMENTS)
(QUOTE EVAL))
(INSTANTIATE (GETP B META:CODE)
))))))
(STRUCTURE:INDUCING:DEMON (SETQ OUTERLIST (CADR (SASSOC (DETERMINE:ARG:VALUE CHOICE)
MEMBER:OF:LIST)))
(SETQ PIECES (MAPCAR (CDAR (CDDADR D))
(FUNCTION (LAMBDA (PIECE)
(COLON:BACK (LIST PIECE (QUOTE PART:OF)
OUTERLIST)))))))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(COND ((LESSP (LENGTH IN:SET:TRANS)
2)
(MAPC (GETP (CAR IN:SET:TRANS)
COMMENTS)
(QUOTE EVAL))
(INSTANTIATE (GETP (CAR IN:SET:TRANS)
META:CODE)))
(T (VECTOR (COND ((GETP (CAR (LAST (CADR D)))
PREDICATE)
(QUOTE PROGN))
(T (QUOTE REPEATEDLY)))
(INVECTOR PROC)
(APPEND (VECTOR COND)
(MAP2CAR IN:SET:TRANS PIECES
(FUNCTION
(LAMBDA
(IST PIECE)
(MAPC (GETP IST COMMENTS)
(QUOTE EVAL))
(VECTOR (COND ((EQUAL (LAST IN:SET:TRANS)
(LIST IST))
T)
(STAG (VECTOR MEMBER ARG1
(@ PIECE)))
(T (VECTOR IS:OF:TYPE ARG1
(LIST VECTOR COMMENT
IST))))
(INVECTOR (PROCEDURE:PULLOUT
PROC
(INSTANTIATE (GETP IST
META:CODE)))))
))))))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ YES YES)
(RPAQQ ASSERT:LISTS
(ABLE:PUP:LIST ABLE:USER:LIST ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST AWARE:PUP:LIST
AWARE:USER:LIST ENCODABLE:SECTION:LIST DOING:PUP:LIST EXECUTABLE:INFO:LIST MEMBER:OF:LIST
LOOP:TERMINATION:LIST TRUE:FN:CALL:LIST DISTINGUISHED:ARG:LIST DISTINGUISHED:INFO:LIST
NEW:THING:LIST RESULT:BINDING:LIST GLOBAL:INITIALIZATION:LIST FRINGE:CONCIOUS:LIST
PARTITIONED:DOMAIN:LIST IS:DEFINED:LIST FN:CALL:LIST IS:SPECIFIC:LIST CODING:WARNING:LIST
RESOLVED:DECISION:LIST KNOWN:NAMES NAMED:EXPRESSION:LIST NEW:INFO:LIST PLAUSIBLE:NAMES:LIST
PUP:SATISFIED:LIST PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST READ:USER:LIST
RELEVANT:INFO:LIST TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST TYPE:OF:LIST
UNDEFERRED:DECISION:LIST USABLE:INFO:LIST USER:WANTS:LIST WRITTEN:PROGRAMS:LIST
DEFERRED:DECISION:LIST UNDEFINED:SECTION:LIST))
(RPAQQ SOMEOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ IS:BEING:LIST
(LIST:STRUCTURE PROBABILITY>0&<1:# PROBABILITY=0:# PROBABILITY=1:# COMPARE:24 COMPARE:23 COMPARE:22 JOIN:21
COMPARE:17 TEST:16 FOREACH:15 GET:HOLD:OF:7 TAKE:HOLD:OF:6 TAKE:HOLD:OF:3 HAS:NAME:5 ELEMENT:4
STATIC:SCENE:8 PARTITION:2 CF:1 RECOGNIZE:# JOINING:FUNCTION COMPARE
RECOGNIZE:FUNCTION:RETURNS FOREACH TEST SEARCH SOME:PART:OF RECOGNIZE:EQUALITY
RECOGNIZE:LITERALS RECOGNIZE:CAR ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS
ASK:USER:ABOUT BETTER CHOOSE:FROM CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION CONCEPT:FORMATION DEFER:DECISION ELEMENT ENCODE
EXTRACT:RELEVANT:SUBSET FILL:IN:UNDEFINED:SECTION GET:HOLD:OF GET:NAME GET:NEW:INFORMATION
IS:OF:TYPE MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION
OBTAIN:USABLE:INFORMATION PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS PROPOSE:PLAUSIBLE:NAMES
REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION SATISFY SCENE SERVE STUDY:TYPE TAKE:HOLD:OF
TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ BEING BEING)
(RPAQQ BREAKUP:LIST (: ; %. , - ?))
(RPAQQ UNTIL UNTIL)
(RPAQQ FUNDAMENTAL:IDEN:TABLE (((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))))
(RPAQQ SINCE SINCE)
(RPAQQ FOREVER FOREVER)
(RPAQQ PRIMITIVE:PROGRAMS:LIST
(AND OR NOT COND T MAPC MAPCAR LAMBDA FUNCTION PLUS TIMES LIST APPEND CONS CAR CDR CADR CADDR CADDDR CADAR
MINUS MINUSP QUOTIENT ADD1 SUB1 SET SETQ NULL QUOTE EVAL LESSP EQUAL TEMPORARILY NIL RELEVANT IRRELEVANT
PROG PROGN CDAR CDDR CAAR CAADR CAAAR CDADR PROG1 READ PRINT PRIN1 PRIN2))
(RPAQQ PRIMITIVE:VARS:LIST (T NIL 0 1 2 3 4 5 6 7 8 9 10 -1 -2 -3))
(RPAQQ Y NOBIND)
(RPAQQ N 2)
(RPAQQ NOT:TIME:YET NOT:TIME:YET)
(RPAQQ CALL CALL)
(RPAQQ COMPILABLE:BEING:PARTS (META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES EXPLICIT:ARGS
EXPLICIT:ARGS:CHECK IMPLICIT:ARGS DEMONS INHIBIT:CURRENT:DEMONS))
(RPAQQ EFFECTS:TABLE (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION))
((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CF:1))
((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2))))
((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1)))
((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1)))
((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1)))
((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN))
((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:2))
((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1)))
((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D))))
((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND))))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))))
(RPAQQ EVAL EVAL)
(RPAQQ PARTS PARTS)
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY PREDICATE DATA:STRUCTURE INHIBIT:CURRENT:DEMONS FORM:CHANGING
ENCODABLE NON:EVAL:ARGS NLAMBDA))
(RPAQQ FALSE FALSE)
(RPAQQ IDEN:TABLE (((@ (AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2)))
(VECTOR MESSAGE (CADR LI)))
((@ (AND (EQUAL (LENGTH LI)
1)
(MEMBER (CAR LI)
PRIMITIVE:VARS:LIST)))
(CAR LI))
((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((@ (MATCH (TUPLE ANY ANY1 IN ANY2 IS FRAG1)
LI))
(VECTOR DO UNTIL (VECTOR FORSOME (@ ANY1)
IN
(@ ANY2)
(TRANSLATE (APPEND (LIST VECTOR ANY1 IS)
FRAG1)
T))))
((@ (MATCH (TUPLE ANY1 IS INCOMPATIBLE WITH ANY2)
LI))
(VECTOR RECOGNIZE:# (@ ANY1)
(@ ANY2)))
((@ (MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI))
(VECTOR MESSAGE (INVECTOR FRAG1)))
((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T)))
((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T))))))
((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI)))
((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI)))
((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((EQUAL LI (LIST SCENE))
(VECTOR SCENE))
((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE))
((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))
((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1)))
((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1))))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1))))
((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI)))
((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T)))
((MATCH (TUPLE A DESCRIPTION OF A FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE THE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(COND ((ATOM (SETQ TTR (TRANSLATE (LIST VECTOR ANY1)
T)))
(LIST TTR))
(T (CDR TTR)))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T))))))
((MATCH (TUPLE THE RESULT OF ANY1)
LI)
(COND ((CADR (SASSOC LI RESULT:BINDING:LIST)))
((SETQ XTEMP (SASSOC ANY1 (OUTVECTOR FN:CALL:LIST)))
(INVECTOR XTEMP))
((LISTP ANY1)
(INVECTOR ANY1))
((LIST VECTOR ANY1))))
((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T)))))
((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((Z@ (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(PROGN (PRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT (TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (RATOM)
(QUOTE (YES Y PROBABLY)))))
(OR (SET ANY1 ANY1)
T)))
ANY1)))
(RPAQQ INFERIOR INFERIOR)
(RPAQQ MINOR:WORDS (A AT DO DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE))
(RPAQQ ING ING)
(RPAQQ NAME NAME)
(RPAQQ NON:EVAL:BEING:PARTS (IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES))
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ PERMANENT:KNOWN:NAMES NIL)
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION USE:INFORMATION FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE OPTIMIZE))
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS
MINOR:EFFECTS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS AFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES PREDICATE DATA:STRUCTURE ENCODABLE
INHIBIT:CURRENT:DEMONS FORM:CHANGING))
(RPAQQ SET:OF:BEINGS
(LIST:STRUCTURE PROBABILITY>0&<1:# PROBABILITY=0:# PROBABILITY=1:# RECOGNIZE:# JOINING:FUNCTION COMPARE
RECOGNIZE:FUNCTION:RETURNS FOREACH TEST SEARCH SOME:PART:OF RECOGNIZE:EQUALITY
RECOGNIZE:LITERALS RECOGNIZE:CAR ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS
ASK:USER:ABOUT BETTER CHOOSE:FROM CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION CONCEPT:FORMATION DEFER:DECISION ELEMENT ENCODE
EXTRACT:RELEVANT:SUBSET FILL:IN:UNDEFINED:SECTION GET:HOLD:OF GET:NAME GET:NEW:INFORMATION
IS:OF:TYPE MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION
OBTAIN:USABLE:INFORMATION PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS PROPOSE:PLAUSIBLE:NAMES
REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION SATISFY SCENE SERVE STUDY:TYPE TAKE:HOLD:OF
TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ SUPERIOR SUPERIOR)
(PUTPROPS LIST:STRUCTURE BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A LIST STRUCTURE ENTITY)
HOW (TUPLE A LIST OF ATOMS AND LIST STRUCTURES)
WHY (TUPLE ASSOCIATE THE PARTS OF THE LIST STRUCTURE)
META:CODE (STRUCTURE (CAR ATOM FRONT OF LIST:STRUCTURE)
(CDR LIST ALL BUT THE FRONT OF THE LIST:STRUCTURE))
COMPLEXITY:VECTOR (.2 .2 .2 .2 .1)
GENERALIZATIONS (TUPLE DATA:STRUCTURE)
DATA:STRUCTURE T)
(PUTPROPS PROBABILITY>0&<1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF THE OBJECT (@ OBJECT)
CONTRADICTS
(@ WORLD)
%. SINCE THE FORMER HAS A PROBABILITY STRICTLY > 0, AND STRICTLY < 1, WE
CANNOT DO THIS EASILY)
HOW (TUPLE SINCE (@ OBJECT)
HAS A PROBABILITY STRICTLY BETWEEN 0 AND 1 OF OCCURRING IN (@ WORLD)
,THERE IS NO EASY WAY TO TEST FOR CONTRADICTION; THUS WE SIMPLY ALWAYS SAY
THAT THERE IS NONE.)
META:CODE (PROGN (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EITHER CASE IS ALLOWABLE;
SO WE NEVER HAVE A CONTRADICTION)
NIL)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS PROBABILITY=0:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
, WHICH MUST OCCUR WITH PROBABILITY = 0 (TUPLE I.E., NEVER)
CONTRADICTS THE PART OF THE WORLD SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
SHOULD NEVER OCCUR IN THE WORLD, IN PARTICULAR WE WILL HAVE A CONTRADICTION IF
IT OCCURS IN (@ WORLD)
;I.E., WE CHECK TO MAKE SURE THAT (@ OBJECT)
IS NOT A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A CONTRADICTION IF IT IS A
MEMBER OF ARG2)
(MEMBER ARG1 ARG2))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS PROBABILITY=1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
,WHICH MUST OCCUR WITH PROBABILITY = 1, CONTRADICTS THE PART OF THE WORLD
SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
MUST OCCUR (TUPLE PROB. = 1)
WE SHALL CHECK TO SEE THAT (@ OBJECT)
IS A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD BETTER BE IN ARG2, THE
RELEVANT PIECE OF THE WORLD)
(NOT (MEMBER ARG1 ARG2)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS RECOGNIZE:# BEING T
IDEN (((@ (MATCH (TUPLE ANY ANY1 IN ANY2 IS FRAG1)
LI))
(VECTOR DO UNTIL (VECTOR FORSOME (@ ANY1)
IN
(@ ANY2)
(TRANSLATE (APPEND (LIST VECTOR ANY1 IS)
FRAG1)
T))))
((@ (MATCH (TUPLE ANY1 IS INCOMPATIBLE WITH ANY2)
LI))
(VECTOR RECOGNIZE:# (@ ANY1)
(@ ANY2))))
PREDICATE T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
IS IN CONTRADICTION TO THE COLLECTION (@ WORLD))
HOW (TUPLE SEE HOW A (@ OBJECT)
TYPE OF OBJECT CAN BE CONTRADICTORY, THEN EXAMINE THE RELATIONSHIP BETWEEN
(@ OBJECT)
AND
(@ WORLD))
META:CODE (PROGN (DETERMINE:CONTRADICTION:CRITERIA)
(CHECK CONTRADICTION:CRITERIA OBJECT WORLD))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
SPECIALIZATIONS (VECTOR (VECTOR SOMEOF (VECTOR PROBABILITY=1:# PROBABILITY=0:#
PROBABILITY>0&<1:#)
AFFECTS
(VECTOR THE RECOGNIZE:# ALGORITHM)
COMMENT
(COMMENT
THE FOLLOWING ARE THE 'HOW' PARTS OF THE ABOVE CHOICES:
(QUOTE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(MAPCAR (CDAR (CDDADR D))
(FUNCTION
(LAMBDA
(CHOI)
(MAP2C (TUPLE ARG1 ARG2 ARG3 ARG4
ARG5 ARG6)
(GETP CHOI EXPLICIT:ARGS)
(FUNCTION
(LAMBDA
(ARGK ARGU)
(SET ARGU (EVAL ARGK)))))
(LIST CHOI (EVAL (GETP CHOI HOW)))))
))))
RECOGNIZE:#)))
(PUTPROPS JOINING:FUNCTION BEING T
EXPLICIT:ARGS ALIST
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE JOIN TOGETHER THE SET (@ ALIST)
OF RESULTS)
HOW (TUPLE USE A JOINING TYPE OF SIMPLE FUNCTION)
WHY (TUPLE WE HAVE SEVERAL TEMPORARY RESULTS, AND WE MUST COMBINE THEM TO PRODUCE A SINGLE
RESULT)
META:CODE (COMMENT DEPENDS UPON THE SPECIFIC FLAVOR OF JOINING REQUIRED. USUSALLY AND, OR,
XOR, SERIES, ... ETC.)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE RELATING:FUNCTION FUNCTION)
SPECIALIZATIONS (VECTOR (VECTOR PREDICATE (VECTOR WHEN WE TERMINATE THE LOOP)
AFFECTS
(VECTOR THE JOINING:FUNCTION ALGORITHM)
RESULTS LOOP:TERMINATION:LIST HOW
(INVECTOR (QUOTE (LAMBDA (PRED)
(COND ((MATCH (TUPLE DO UNTIL
FRAG1)
PRED)
(QUOTE AND))
((MATCH (TUPLE DO
REPEATEDLY
FRAG1)
PRED)
(QUOTE PROGN))
(T PRED)))))
JOINING:FUNCTION))
ALTERNATIVES (TUPLE SELECTING:FUNCTION ELIMINATING:FUNCTION)
PREDICATE T)
(PUTPROPS COMPARE BEING T
EXPLICIT:ARGS (POSSIBLE:OBJECT IDEAL:OBJECT)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE COMPARE (@ POSSIBLE:OBJECT)
WITH
(@ IDEAL:OBJECT))
HOW (TUPLE BY APPLYING A FUNCTION (TUPLE PROBABLY ALREADY KNOWN)
TO EITHER THESE TWO OBJECTS, OR ELSE TO THEIR CORRESPONDING PARTS.)
WHY (TUPLE PUP WANTS TO SEE IF (@ POSSIBLE:OBJECT)
IS CLOSE ENOUGH TO (@ IDEAL:OBJECT))
META:CODE (COMMENT DEPENDS UPON THE PARTICULAR FLAVOR OF COMPARISON)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE TEST)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(TUPLE PROGN (VECTOR COMPARING MAY INVOLVE A FUNCTION APPLIED DIRECTLY TO THE
TWO ARGUMENTS)
(VECTOR COMPARING MAY INVOLVE APPLYING A FUNCTION TO CORRESPONDING PAIRS
OF SUBPARTS OF THE OBJECTS, AND FINALLY JOINING TOGETHER ALL
THESE SUB-COMPARISONS' RESULTS)
(QUOTE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(SETQ H1 (HIGHLY:STRUCTURED ARG1))
(SETQ H2 (HIGHLY:STRUCTURED ARG2))
(SETQ C12 (STRUCTURE:COMPATIBLE ARG1 ARG2))
(COND ((AND H1 H2 C12)
NIL)
((AND H1 H2)
(ERROR))
((OR H1 H2)
NIL)
(T T)))))
AFFECTS
(VECTOR THE COMPARE ALGORITHM)
RESULTS
(VECTOR (QUOTE (COND ((SETQ SA (CADR (SETQ SC (SASSOC (CADR CHOICE)
LOOP:TERMINATION:LIST))))
(COND ((MEMBER SA PRIMITIVE:VARS:LIST)
(VECTOR PROGN ARG1 ARG2
(COMMENT THE PRESENCE OF ARG1 AND ARG2
ABOVE DOES NO HARM; IT IS
NECESSARY SOMEWHERE IN THE
FUNCTION SO THAT PUP WILL INSERT
COMMENTS ABOUT WHAT ARG1 AND ARG2
GET INSTANTIATED AS.)
(COMMENT SINCE THIS COMPARISON PREDICATE
MUST ALWAYS RETURN THE CONSTANT
VALUE (@ SA)
,ALL THAT (CADR CHOICE)
CAN POSSIBLY BE IS A SEQUENCE OF
ASSIGNMENTS, REWRITES, AND
ITERATIVE STATEMENTS, ENDING WITH
(@ SA))
(@ SA)))
(T (SETQ SB (CADR SA))
(VECTOR PROGN
(COMMENT HERE WE MAY LATER WANT TO PUT
SOME ASSIGNMENTS, REWRITES, AND
ITERATIVE STATEMENTS)
(VECTOR COND (VECTOR
(VECTOR NOT (INVECTOR SB))
(CADDR SC))
(INVECTOR (CADDDR SC)))))))
(T (VECTOR JOINING:FUNCTION ARG1 ARG2))))
(QUOTE (APPEND (VECTOR JOINING:FUNCTION)
(COND
((HIGHLY:STRUCTURED ARG1)
(MAPCAR (CDR (GETP ARG1 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE HOLD:ANY1 SECOND:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF
(CONS VECTOR
PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ SECOND:OBJ
(SUBST ARG2 (CAR (COLON:BREAK
ARG1))
(COPY (COLON:BREAK HOLD:ANY1)
)))
(SETQ
SECOND:OBJ
(COND
((MEMBER ARG2 SECOND:OBJ)
SECOND:OBJ)
(T (APPEND SECOND:OBJ
(LIST (QUOTE OF)
ARG2)))))
(COND
((NUMBERP (CAR (LAST SECOND:OBJ)))
(SETQ
SECOND:OBJ
(REVERSE (CONS (SETQ NEW:F:NUMBER
(ADD1
NEW:F:NUMBER))
(CDR (REVERSE
SECOND:OBJ)))))
))
(SETQ SECOND:OBJ (COLON:BACK SECOND:OBJ))
(LIST VECTOR COMPARE HOLD:ANY1 SECOND:OBJ)
))))
((HIGHLY:STRUCTURED ARG2)
(MAPCAR (CDR (GETP ARG2 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE HOLD:ANY1 FIRST:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF
(CONS VECTOR
PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ FIRST:OBJ
(SUBST ARG1 (CAR (COLON:BREAK
ARG2))
(COPY (COLON:BREAK HOLD:ANY1)
)))
(SETQ
FIRST:OBJ
(COND
((MEMBER ARG1 FIRST:OBJ)
FIRST:OBJ)
(T (APPEND FIRST:OBJ
(LIST (QUOTE OF)
ARG1)))))
(COND
((NUMBERP (CAR (LAST FIRST:OBJ)))
(SETQ
FIRST:OBJ
(REVERSE (CONS (SETQ NEW:F:NUMBER
(ADD1
NEW:F:NUMBER))
(CDR (REVERSE
FIRST:OBJ)))))
))
(SETQ FIRST:OBJ (COLON:BACK FIRST:OBJ))
(LIST VECTOR COMPARE FIRST:OBJ HOLD:ANY1))
)))))))
COMPARE)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT
VECTOR:RESULT)
AFFECTS
(VECTOR THE TERMINATION CHARACTERISITCS OF THE COMPARING)
WHEN
(VECTOR BEFORE THE COMPARING ROUTINE IS FINALIZED)
COMPARE))
PREDICATE T)
(PUTPROPS RECOGNIZE:FUNCTION:RETURNS BEING T
IDEN (((MATCH (TUPLE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((MATCH (TUPLE THE RESULT OF ANY1)
LI)
(COND ((CADR (SASSOC LI RESULT:BINDING:LIST)))
((SETQ XTEMP (SASSOC ANY1 (OUTVECTOR FN:CALL:LIST)))
(INVECTOR XTEMP))
((LISTP ANY1)
(INVECTOR ANY1))
((LIST VECTOR ANY1))))
((MATCH (TUPLE THE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS FOREACH BEING T
EXPLICIT:ARGS (X IN XSET DO ACTION)
EXPLICIT:ARGS:CHECK T
NLAMBDA T
NON:EVAL:ARGS T
WHAT (TUPLE GO THROUGH THE KNOWN SPACE OF (PLURAL X)
,WHICH IS (@ XSET)
,AND PERFORM (@ ACTION)
ON EACH, UNTIL SOME SPECIFIED TERMINATION CONDITION IS REACHED)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE LOOP REPEATEDLY)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR I ASSUME THAT I STOP AFTER EXAMINING ALL (PLURAL X)
IN
(@ XSET)
; DO I ALSO STOP AFTER SOME CONDITION 'C' BECOMES TRUE?)
COMMENT
(COMMENT THIS CONDITION 'C' SHOULD BE A PREDICATE, WHOSE SINGLE ARGUMENT IS
(@ X)
.'C' WORKS LIKE AN 'UNTIL' CLAUSE IN AN ITERATIVE STATEMENT. WE TEST
(PLURAL X)
UNTIL ONE OF THEM MAKES 'C' HAVE A NON-NULL VALUE. AT THAT TIME THE
FOREACH FUNCTION WILL RETURN A VALUE AND END.)
AFFECTS
(VECTOR THE FOREACH ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ DELTA:SECTION:1
(VECTOR COMMENT IF A CONDITIONAL TERMINATION IS LATER ADDED, IT
WILL PROBABLY REPLACE THIS COMMENT))
(SETQ DELTA:SECTION:2 (VECTOR GO (@ TEMPL)))))
BOTH:RESULTS
(QUOTE
((SETQ ARG:COMMENTS NIL)
(SETQ ARG:COUNTER 0)
(SETQ FCALL (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(MAP2C (CDR FCALL)
(GETP FOREACH EXPLICIT:ARGS)
(FUNCTION (LAMBDA (FA1 FA2)
(SETQ ARG:COUNTER (ADD1 ARG:COUNTER))
(COND ((MEMBER FA1 TRIVIAL:BEING:LIST)
(SET FA2 FA1))
(T (SET FA2 (PACK (TUPLE ARG (@ ARG:COUNTER)))
)
(SETQ ARG:COMMENTS
(NCONC1 ARG:COMMENTS
(COMMENT IN ALL CALLS TO
DATE, (EVAL FA2)
IS BOUND TO
(INCOMMENT FA1))))))
)))
(SETQ
TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (VECTOR PROGN)
ARG:COMMENTS
(LIST (TUPLE PROG
(VECTOR (SETQ
TRESULT
(COLON:BACK
(TUPLE RESULT
(SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(VECTOR SETQ
(SETQ
EV:SET
(COLON:BACK
(LIST (QUOTE EVAL)
XSET)))
(VECTOR EVAL (@ XSET)))
(SETQ TEMPL
(COLON:BACK
(TUPLE LABEL (SETQ
LABEL:COUNTER
(ADD1 LABEL:COUNTER))))
)
(VECTOR COND
(VECTOR (VECTOR NULL
(@ EV:SET))
(VECTOR RETURN
EXHAUSTION:VALUE)))
(VECTOR COMMENT WARNING
EXHAUSTION:VALUE UNDEFINED;
WILL BE GOTTEN LATER; PROBABLY
(@ TRESULT))
(VECTOR SET (@ X)
(VECTOR CAR (@ EV:SET)))
(VECTOR SETQ (@ EV:SET)
(VECTOR CDR (@ EV:SET)))
(VECTOR SETQ (@ TRESULT)
(VECTOR EVAL (@ ACTION)))
(EVAL DELTA:SECTION:1)
(EVAL DELTA:SECTION:2)))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
YES:RESULTS
(QUOTE
((SETQQ
DELTA:SECTION:1
(VECTOR
COND
(VECTOR
(PROGN
(PRIN1
"
PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
USER: ")
(SETQ RESULT:BINDING:LIST (CONS (LIST (TUPLE THE RESULT OF ACTION)
TRESULT)
RESULT:BINDING:LIST))
(SETQ RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(COND
((SOME ARG:COMMENTS
(FUNCTION
(LAMBDA
(ACM)
(MATCH (COMMENT IN ALL CALLS
TO DATE,
(@ ACTION)
IS BOUND TO
(COMMENT
ANY2 FRAG1))
ACM))))
(SETQ RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(@ ACTION))
TRESULT)
RESULT:BINDING:LIST))
ANY2)
(ACTION)))
TRESULT)
RESULT:BINDING:LIST))
(TRANSLATE (INVECTOR (READ))
T))
(VECTOR RETURN UNTIL:CONDITION:VALUE))
(VECTOR T (VECTOR GO (@ TEMPL)))))
(SETQQ DELTA:SECTION:2
(CAR (SETQ CODING:WARNING:LIST
(CONS (VECTOR COMMENT WARNING UNTIL:CONDITION:VALUE
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY
EITHER NIL OR (COMMENT EVAL UNTIL:CONDITION)
OR
(COMMENT EVAL (@ X)))
CODING:WARNING:LIST))))))
FOREACH)))
(PUTPROPS TEST BEING T
EXPLICIT:ARGS (ENTITY DESCRIPTION:OF:CONDITION)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TEST TO SEE IF THE ENTITY (@ ENTITY)
MEETS THE DESIRED CONDITIONS (@ DESCRIPTION:OF:CONDITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(PROGN (VECTOR THE TESTING MAY HAVE THE CHARACTER OF COMPARING THE
OBJECT (VECTOR THAT IS, ARG1, ALSO KNOWN AS
(TUPLE TUPLE CADDR ENT1))
WITH SOME DISTINGUISHED OBJECT)
(VECTOR TESTING MAY HAVE THE CHARACTER OF LETTING THE OBJECT
(VECTOR WHICH IS ARG1)
COMPETE WITH ITS FELLOW OBJECTS FOR SUPREMACY)
(COND ((INFER:INSIDE (CADR CHOICE)
FOREACH)
T)
((INFER:INSIDE (CADR CHOICE)
EXTREMUM)
NIL)
(T (ERROR))))
AFFECTS
(VECTOR THE TEST ALGORITHM)
RESULTS
(VECTOR (VECTOR COMPARE ARG1 (MOST:GENERAL NEW:THING:LIST))
(VECTOR REPEATEDLY (VECTOR COMPARE ARG1 CURRENT:BEST:ARG1)
(VECTOR REVISE CURRENT:BEST:ARG1)))
COMMENT
(COMMENT THE "DISTINGUISHED OBJECT" IS ASSUMED TO BE A NEWLY-ACQUIRED
ONE, PROBABLY JUST READ IN. IT WILL BE ONE OF THESE:
(@ NEW:THING:LIST)
;PROBABLY THIS ONE: (MOST:GENERAL NEW:THING:LIST)
%. "COMPETING" MEANS THAT EACH ARG1 IS COMPARED WITH THE
PARTICULAR OLD ARG1-VALUE WHICH HAS
(VECTOR SO FAR, AT LEAST)
RECEIVED THE HIGHEST RATING; I.E., DEFEATED ALL CHALLENGERS.
THUS, THE ARG1-VALUE RETAINED AT THE END SHOULD BE THE BEST
ONE. THIS PRESUPPOSES THAT THE COMPARISON FUNCTION IS
TRANSITIVE.)
TEST)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT)
AFFECTS
(VECTOR WHETHER NO OTHER, ALL OTHER, OR ALL OTHER OBJECTS MUST BE
EXAMINED)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO TEST (TUPLE TUPLE CADDR ENT1))
TEST)))
(PUTPROPS SEARCH BEING T
EXPLICIT:ARGS (GOAL SPACE)
EXPLICIT:ARGS:CHECK SPACE
WHAT (TUPLE SEARCH THROUGH A KNOWN, FINITE SPACE (@ SPACE)
FOR AN ELEMENT SATISFYING THE GOAL (@ GOAL))
HOW (TUPLE EXAMINE MEMBER OF SPACE TO SEE IF IT MEETS CRITERIA)
WHY (TUPLE BECAUSE PUP MUST GET A MEMBER OF (@ SPACE)
WHICH SATISFIES (@ GOAL))
META:CODE (FOREACH ($ X)
IN
($ XSET)
DO
($ (TUPLE TEST (@ X)
(COMMENT FOR SATISFACTION OF GOAL CRITERIA))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS ((COMMENT HER WE MUST NOTE THE TERMINATION CONDS.))
ALTERNATIVES (TUPLE GENERATE:AND:TEST COMPUTE)
IMPLICIT:ARGS (X XSET)
COMMENTS ((PROGN (DETERMINE:ARG:VALUE CHOICE)
(SETQ X (COLON:BACK (LIST POSSIBLE ARG1)))
(SETQ XSET (COLON:BACK (LIST SET:OF (PLURAL X)))))))
(PUTPROPS SOME:PART:OF BEING T
EXPLICIT:ARGS (LIST:STRUC)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE THIS IS A DESTRUCTIVE FUNCTION; IT BREAKS A PIECE OFF OF (@ LIST:STRUC))
HOW (TUPLE USE SOME PRE:EXISTING TECHNIQUE TO GET THE SIMPLE LISP PROGRAM
(TUPLE MADE UP OF CARS AND CDRS)
WHICH DOES THE JOB. SUCH FACILITIES MIGHT BE PW1, PUP, DAVID SHAW'S PGM, OR EVEN
TRIAL AND ERROR.)
WHY (TUPLE ONLY PART OF (@ LIST:STRUC)
IS DESIRED AT THIS POINT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .9)
GENERALIZATIONS (TUPLE FUNCTION SUBROUTINE PROGRAM SYSTEM)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY (QUOTE (PROGN (VECTOR WE GET THE SOME:PART:OF
FUNCTION (CADR CHOICE)
BY EXAMPLE I/O)
(VECTOR WE GET THE SOME:PART:OF
FUNCTION (CADR CHOICE)
BY TRANSLATING AN EXPLICITLY
USER-PROVIDED SENTENCE)
(ERROR!)))
RESULTS
(VECTOR (QUOTE (LEARN:BY:EXAMPLE (VECTOR SOME:PART:OF
(CADR CHOICE)
(DETERMINE:ARG:VALUE
CHOICE)
(DETERMINE:ARG2:VALUE
CHOICE))))
(QUOTE (PROGN (PRIN1
"
OK, NOW TYPE IN THE SENTENCE EQUIVALENT TO THE ACTION OF THE
SOME:PART:OF:FUNCTION IN QUESTION
USER: ")
(TRANSLATE (INVECTOR (READ))
T))))
AFFECTS
(VECTOR THE SOME:PART:OF ALGORITHM)
SOME:PART:OF)))
(PUTPROPS RECOGNIZE:EQUALITY BEING T
IDEN (((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:LITERALS BEING T
IDEN (((Z@ (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(PROGN (PRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT
(TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (RATOM)
(QUOTE (YES Y PROBABLY)))))
(OR (SET ANY1 ANY1)
T)))
ANY1)
((@ (AND (EQUAL (LENGTH LI)
1)
(MEMBER (CAR LI)
PRIMITIVE:VARS:LIST)))
(CAR LI)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
POST:REQUISITES ((VECTOR GLOBAL INITIALIZATION ANY1)))
(PUTPROPS RECOGNIZE:CAR BEING T
IDEN (((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(COND ((ATOM (SETQ TTR (TRANSLATE (LIST VECTOR ANY1)
T)))
(LIST TTR))
(T (CDR TTR)))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T)))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS ADD:DEFINITION BEING T
IDEN (((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T))))
EXPLICIT:ARGS (OBJECT DEFINITION)
EXPLICIT:ARGS:CHECK (ATOM OBJECT)
WHAT (TUPLE ADD THE DEFINITION OF (@ OBJECT)
AS
(@ DEFINITION)
TO PUP'S KNOWLEDGE)
HOW (TUPLE TRIVIALLY, ADD THE DEFN. TO EXISTING DEFNS.)
WHY (TUPLE THE OBJECT (@ OBJECT)
HAS BEEN REFERENCED, AND PUP FEELS UNCOMFORTABLE DISCUSSING ENTITIES IT CAN'T
DEFINE)
META:CODE (PROGN (SETQ ENCODABLE:SECTION:LIST (CONS OBJECT ENCODABLE:SECTION:LIST))
(SETQ TYPE:OF:LIST (MAPCAR TYPE:OF:LIST (FUNCTION
(LAMBDA (TOL)
(COND ((MATCH (VECTOR (@ OBJECT)
TYPE OF ANY1 IS
FRAG1 USED IN
ANY2)
TOL)
(VECTOR (@ OBJECT)
TYPE OF (@ ANY1)
IS
(@ DEFINITION)
AND IS USED IN
(@ ANY2)))
(T TOL))))))
(SETQ IS:DEFINED:LIST (NCONC1 IS:DEFINED:LIST (VECTOR (@ OBJECT)
IS
(@ DEFINITION)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NON:EVAL:ARGS T)
(PUTPROPS ADJECTIVE:HANDLER BEING T
IDEN (((MATCH (TUPLE A DESCRIPTION OF A FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T))))))
IMPLICIT:ARGS (TNAME BNAME CODE TCODE MCODE)
EXPLICIT:ARGS (ADJ NOUN:GROUP)
EXPLICIT:ARGS:CHECK (MEMBER ADJ ADJECTIVES)
WHAT (TUPLE HANDLE THE ADJECTIVE (@ ADJ)
MODIFYING THE NOUN GROUP (@ NOUN:GROUP))
HOW (TUPLE LOOK AT (@ NOUN:GROUP)
AND SELECT THOSE PARTS WHICH ARE NOT CONTRADICTED BY THE ADJECTIVE
(@ ADJ))
WHY (TUPLE BECAUSE THE (@ ADJ)
PARTS OF (@ NOUN:GROUP)
ARE WANTED, AND THE (OPPOSITE ADJ)
PARTS ARE UNWANTED)
META:CODE (PROGN (SETQ FARGS NIL)
(SETQ BNAME (CAR (LAST NOUN:GROUP)))
(SETQ MCODE (GETP BNAME META:CODE))
(SETQ CODE (COND ((SETQ TCODE (SASSOC (OPPOSITE ADJ)
MCODE))
(PROCEDURE:PULLOUT TCODE MCODE))
((SETQ TCODE (SASSOC ADJ MCODE))
(CONS (CAR MCODE)
(CDR TCODE)))
(T MCODE))))
PRE:REQUISITES ((VECTOR NAMED EXPRESSION (INVECTOR (OUTTUPLE (CONS ADJ NOUN:GROUP)))
(SETQQ TNAME TNAME)))
POST:REQUISITES ((VECTOR IS BEING (@ TNAME)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
COMMENTS ((SET TNAME TNAME)))
(PUTPROPS ANALYZE:IMPLICATIONS IDEN (((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS OF SOME OF THE NEW INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS OF THE NEW INFO AND STUDYING THEM)
WHY (TUPLE TO IMPROVE THE UNDERSTANDING THAT PUP HAS OF THE NEW INFORMATION
(@ NEW:INFO))
WHEN (((SETQ ANY1 (CAR USABLE:INFO:LIST))
-60
(TUPLE BECAUSE WE SHOULD USE (@ ANY1)
BEFORE WORRYING ABOUT (@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO))
(TUPLE BECAUSE THE SIZE OF THE NEW INFORMATION (@ NEW:INFO)
AFFECTS HOW EASILY AND FRUITFULLY AN ANALYSIS OF IT WILL BE)))
META:CODE (PROGN (LOCATE:AFFECTED:AREA NEW:INFO)
(PREDICT:AFFECT NEW:INFO)
(EVALUATE:AFFECT NEW:INFO))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO RELEVANT:INFO:LIST)
MAIN:EFFECTS (((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1))))
AFFECTS (QUOTE ((LOCATE AFFECTED:AREA CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT CALLED)))
COMPLEXITY:VECTOR (.4 .7 .7 .5 .1))
(PUTPROPS ASK:USER:ABOUT BEING T
IMPLICIT:ARGS (DTYPE IN:SET IN:SET:TRANS TEMPFNVAL)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ASK THE USER TO RESOLVE DECISION (@ D))
HOW (TUPLE ASK THE USER WHAT THE RESOLUTION IS)
WHY (TUPLE BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
META:CODE (PROGN (TERPRI)
(SETQ DTYPE (CADADR D))
(PRIN1 "PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS ")
(PRIN1 DTYPE)
(PRIN1 " DECISION:")
(PRIN1 (CDAR (CDDADR D)))
(COND ((MEMBER (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(T (SETQ TEMPFNVAL (EVAL (EVAL (COLON:BACK (LIST DTYPE (CADR
BEING:STACK)
KNOWLEDGE)))))
(COND ((STRINGP TEMPFNVAL)
T)
(T TEMPFNVAL)))))
COMPLEXITY:VECTOR (.6 .6 .6 .6 .1))
(PUTPROPS BETTER IDEN (((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T))))
BEING T
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF (@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF (@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
META:CODE (PROGN (SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW (CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW (CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE (WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
(COND ((EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER (CAR B1NEW)
(CAR B2NEW)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PARTS OF (@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
(@ (COND (RESULT1 (QUOTE LESS))
(T (QUOTE MORE))))
COMPLEX THAN THE LATTER BEING))))
(T (SETQ RESULT1 (NOT (MINUSP WHEN:DIFF)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1 SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW)))))))
RESULT1)
EXPLICIT:ARGS:CHECK (AND (EQUAL T (GETP (CAR B1)
BEING))
(EQUAL T (GETP (CAR B2)
BEING)))
PREDICATE T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS CHOOSE:FROM IDEN (((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T)))))))
BEING T
IMPLICIT:ARGS (EXP:TEST)
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET (@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
META:CODE (PROG (BEST)
(SETQ BEST (CAR S))
(SETQ BECAUSE (VECTOR WE MUST SELECT THE BEST BEING FROM
(INVECTOR (MAPCAR S (QUOTE CAR)))))
(COND ((SINGLETON S)
(SETQ BECAUSE (APPEND BECAUSE (VECTOR AND, TRIVIALLY,
(INVECTOR (CAR S))
IS OUR ONLY CHOICE))))
(T (MAPC (CDR S)
(FUNCTION (LAMBDA (S1)
(COND ((EQUAL T (BETTER S1 BEST))
(SETQ BEST S1))))))))
(SETQ BECAUSE (VECTOR NOW THAT WE HAVE SELECTED (CAR BEST)
AS THE BEST BEING OUT OF THE SET (MAPCAR S (QUOTE CAR))
WE MUST CARRY OUT (INVECTOR BEST)))
(COND ((SETQ TEMPBB (EVAL BEST))
(SETQ UNKNOWN:TASK TEMPBB))
((CDR S)
(CHOOSE:FROM (PULLOUT BEST S)))))
EXPLICIT:ARGS:CHECK (PROGN (SETQ EXP:TEST T)
(MAPC S (FUNCTION (LAMBDA (S1)
(COND ((NOT (EQUAL T (GETP (CAR S1)
BEING)))
(SETQ EXP:TEST NIL))))))
(COND (EXP:TEST)
(T (PRIN1 (VECTOR WARNING, WARNING; NOT ALL OF
(MAPCAR S (QUOTE CAR))
ARE BEINGS)))))
COMPLEXITY:VECTOR (.2 .4 .6 .5 .1))
(PUTPROPS CLASSIFICATORY:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN HOW TO DISTINGUISH NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION OF THE DOMAIN OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS COMPARITIVE:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN TO DISTINGUISH AND RANK NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION AND AN ORDERING OF THE RESULTANT
SUBSETS OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION)))
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT STRUCTURING UPON A DOMAIN; LEARN HOW TO
CHARACTERIZE, OR AT LEAST DISTINGUISH, VARIOUS CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE OF CONCEPT FORMATION CALLED FOR, AND THEN
CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY TO CONCEPT KNOWLEDGE)
WHEN (((MEMBER TYPE:OF:C:F ABLE:PUP:LIST)
-70
(TUPLE BECAUSE IF WE CAN ALREADY DO (@ TYPE:OF:C:F)
THEN WE SHOULDNT TRY TO DO IT OVER AGAIN))
((MEMBER (QUOTE (CHARACTERIZE CLASSES))
PUP:WANTS:LIST)
88
(QUOTE (BECAUSE CONCEPT FORMATION IS A GOOD WAY TO GET A CHARACTERIZATION OF
CLASSES)))
(T (COND (NEW:INFO:LIST -60)
(T 40))
(QUOTE (BECAUSE NEW INFORMATION MIGHT ALTER OUR COURSE OF ACTION))))
META:CODE (EVAL (LIST TYPE:OF:C:F))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WORK ON CONCEPT FORMATION))
(VECTOR TYPE OF CONCEPT:FORMATION IS TYPE:OF:C:F)
(VECTOR AWARE USER
(VECTOR THE TYPE OF CONCEPT FORMATION PUP IS ABOUT TO WORK ON IS
(@ TYPE:OF:C:F))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP HAS THOUGHT ABOUT THE (@ TYPE:OF:C:F)
TYPE OF CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE INFERENCE:DEMONS ATTENTION:DEMONS)
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION)))
AFFECTS (TUPLE (TUPLE (EVAL TYPE:OF:C:F)
CALLED))
COMPLEXITY:VECTOR (.1 .5 .5 .5 .1)
GENERALIZATIONS (ATTEND LEARN INDUCTIVE:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR ALTERNATIVES (VECTOR CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION
METRICAL:CONCEPT:FORMATION)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR CONCEPTS MAY VARY WITH TIME)
AFFECTS
(VECTOR THE BASIC STRUCTURE OF FORMING A CONCEPT)
CONCEPT:FORMATION)
(VECTOR BOOLEAN
(VECTOR CONCEPT FORMATION MAY DEPEND UPON THE SPEED OF
PRESENTATION OF THE STIMULI)
AFFECTS
(VECTOR THE AMOUNT OF EFFORT (@ TASK:NAME)
SHOULD SPEND ON IDENTIFYING EACH STIMULUS)
CONCEPT:FORMATION)
(VECTOR DICHOTOMY
(VECTOR (VECTOR INSTANCES MAY BE LEFT IN VIEW
INDEFINITELY)
(VECTOR INSTANCES MAY BE REMOVED AFTER PROCESSING)
)
RESULTS
(VECTOR (VECTOR NEW RELATIONS CAN BE DERIVED AS NEEDED)
(VECTOR ALL RELATIONS MUST BE DERIVED UPON
INITIAL EXPOSURE TO THE STIMULUS))
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO GET RELATIONS FROM
INPUT STIMULI)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR CONJUNCTIVE:CONCEPT:FORMATION
DISJUNCTIVE:CONCEPT:FORMATION
MIXED:CONJUNCTIVE:AND:DISJUNCTIVE:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW (@ TASK:NAME)
STORES THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:TRANSFER:CONCEPT:FORMATION
NEGATIVE:TRANSFER:CONCEPT:FORMATION
NO:TRANSFER:CONCEPT:FORMATION
POSITIVE:AND:NEGATIVE:TRANSFER:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW PREVIOUSLY:LEARNED CONCEPTS AND
PREVIOUSLY:ENCOUNTERED STIMULI AFFECT THE
LEARNING OF NEW CONCEPTS AND THE RECOGNITION THAT
A NEW CONCEPT IS NEW)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO SEARCH THROUGH THE
SET OF CONCEPTS)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:INSTANCE:UTILIZATION
NEGATIVE:INSTANCE:UTILIZATION
POSITIVE:AND:NEGATIVE:INSTANCE:UTILIZATION)
AFFECTS
(VECTOR WHAT INFORMATION (@ TASK:NAME)
MAY USE TO MODIFY THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
OF (@ TASK:NAME))
AFFECTS
(VECTOR WHETHER PARAMETERS DESCRIBING AN INDIVIDUAL MUST
BE READ IN BY (@ TASK:NAME))
WHEN
(VECTOR BEFORE ANY ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE ANY PROCESSING ROUTINE MAY HAVE TO DEPEND
UPON SOME INDIVIDUAL PARAMETERS)
CONCEPT:FORMATION)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN (@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
CONCEPT:FORMATION))
ALTERNATIVES ((GRAMMATICAL:INFERENCE PATTERN:RECOGNITION SIMULATED:EVOLUTION))
LIST (NIL . #7000))
(PUTPROPS DEFER:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1))))
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (MEMBER D UNDEFERRED:DECISION:LIST)
WHAT (TUPLE DEFER THE DECISION (@ D)
AS LONG AS POSSIBLE)
HOW (TUPLE DECIDE WHEN THE CONSEQUENCES OF DECISION (@ D)
WOULD NEXT AFFECT OUR WRITING THE PROGRAM CODE, AND THEN DEMONIZE THAT SITUATION)
WHY (TUPLE THE LONGER WE CAN DEFER ANY DECISION, INCLUDING (@ D)
,THE GREATER THE CHANCES THAT WE WILL HAVE GAINED ENOUGH NEW KNOWLEDGE OF THE
TASK THAT WHEN WE MUST FINALLY CONSIDER (@ D)
WE WILL KNOW ENOUGH TO ANSWER IT EASILY)
MAIN:EFFECTS (((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1))))
WHEN ((UNDEFERRED:DECISION:LIST 40
(VECTOR BECAUSE THERE EXIST UNDEFERRED DECISIONS, SO WE MUST
LOOK AFTER THEM IN SOME WAY BEFORE PROCEDING))
((MEMBER D UNDEFERRED:DECISION:LIST)
89
(VECTOR BECAUSE (@ D)
IS ONE OF THOSE UNDEFERRED DECISIONS)))
META:CODE (PROGN (SETQ UNDEFERRED:DECISION:LIST (PULLOUT D UNDEFERRED:DECISION:LIST))
(SETQ SITU (WHEN:NEXT (VECTOR PUP REINVESTIGATE (@ D))))
(COND ((EQUAL (CAR SITU)
VECTOR)
(SETQ SITU (CDR SITU))))
(COND ((EVAL SITU)
(RESOLVE:DECISION (VECTOR (@ D)
SINCE
(@ SITU))))
((EQUAL SITU (LIST FOREVER))
T)
(T (SETQ DEFERRED:DECISION:LIST (CONS (VECTOR (@ D)
UNTIL
(@ SITU))
DEFERRED:DECISION:LIST)))))
AFFECTS (QUOTE ((WHEN:NEXT CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS ELEMENT BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A STRUCTURE WHICH IS A MEMBER OF A LARGER STRUCTURE)
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION (VECTOR WHAT IS AN ELEMENT)
AFFECTS
(VECTOR CODE INVOLVING ELEMENT)
ELEMENT))
COMPLEXITY:VECTOR (.3 .3 .3 .3 .1)
IDEN (((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT)))
DATA:STRUCTURE T)
(PUTPROPS ENCODE BEING T
IDEN (((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI)))
IMPLICIT:ARGS (FNAME FDESC F1 CODE FARGS YY ORIG:FUNC ARG:LIST ARG:COMMENTS PCOUNT FARGS1 FARGS2
TEMPFARGS CFLAT)
EXPLICIT:ARGS (FUNC)
EXPLICIT:ARGS:CHECK (PROGN
(SETQ ORIG:FUNC FUNC)
(AND (OR (AND (MATCH (VECTOR (VECTOR FRAG1)
NAME ANY1 FRAG2 ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2)
(SETQ F1 (CADR FDESC)))
(COND ((ATOM FUNC)
NIL)
(T (SETQ FUNC (CADR FUNC))
NIL))
(AND (MEMBER T (MAPCAR (REVERSE TYPE:OF:LIST)
(FUNCTION
(LAMBDA
(TT)
(COND
((EQUAL (CADR TT)
FUNC)
(SETQ F1 (SETQ FDESC
(CADDDR (CDDDR TT))))
(SETQ FNAME FUNC)
(SETQ
BNAME
(CAR (OUTVECTOR (CADDR (CDDR TT)))))
T))))))
(COND ((NULL F1)
(SETQ F1 FNAME)
(SETQ TYPE:OF:LIST (NCONC1 TYPE:OF:LIST
(VECTOR (@ F1)
IS
(SUBPAIR (GETP BNAME
EXPLICIT:ARGS)
(CDR FUNC)
(GETP BNAME
META:CODE)
T)))))
((MEMBER (VECTOR (@ FUNC)
TYPE OF (LIST VECTOR BNAME))
ENCODABLE:SECTION:LIST))
((MEMBER FUNC ENCODABLE:SECTION:LIST)))))
(OR (SATISFY (VECTOR ENCODABLE SECTION ORIG:FUNC))
(SATISFY (VECTOR ENCODABLE SECTION FUNC)))))
WHAT (VECTOR ENCODE A FUNCTION NAMED (@ FNAME)
TO ACCOMPLISH (@ BNAME)
BY USING, AMONG OTHER FACTS, (@ FDESC))
HOW (VECTOR DEFINE (@ FNAME)
USING
(@ FDESC))
WHY (VECTOR (@ FNAME)
IS CURRENTLY UNDEFINED)
META:CODE (PROGN (MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (PC)
(COND ((MATCH (VECTOR (@ F1)
IS FRAG1)
PC)
(SETQ CODE FRAG1))))))
(COND ((NULL CODE)
(PRIN1 "
PUP IS NOW GOING TO ENCODE THE PIECE
")
(PRETTYPRINT (LIST (LIST (OUTVECTOR F1))))
(PRIN1 "
OF THE FUNCTION ")
(PRIN1 FNAME)
(PRIN1
" INTO LISP. FUNCTION NAMES WILL
BE QUERIED IN PREORDER, AS NEEDED.
")
(SETQ ARG:LIST (CDR (SASSOC FNAME (OUTVECTOR FN:CALL:LIST))))
(SETQ CODE (LIST (GETCODE (OUTVECTOR F1)
FNAME 1)))
(SETQ FARGS (INTERSECTION FARGS FARGS))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS TRIVIAL:BEING:LIST))))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS ARG:LIST))))
(COND ((LESSP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (APPEND FARGS (DUMMIES (DIFFERENCE (LENGTH ARG:LIST)
(LENGTH FARGS))))))))
(T (SETQ FARGS (APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(SETDIFFERENCE (OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST PUP5FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST IS:BEING:LIST
SET:OF:BEING:PARTS PUP5VARS))))))
(SETQ FARGS1 (MAPCONC FARGS (FUNCTION (LAMBDA (FF)
(COND ((MATCH (TUPLE A R G FRAG1)
(UNPACK FF))
(LIST FF)))))))
(SETQ FARGS2 (SETDIFFERENCE FARGS FARGS1))
(SETQ FARGS1 (SORT (COPY FARGS1)))
(SETQ TEMPFARGS NIL)
(SETQ PCOUNT 0)
(MAPC FARGS (FUNCTION (LAMBDA NIL (SETQ PCOUNT (ADD1 PCOUNT))
(COND ((MATCH (TUPLE A R G (@ PCOUNT))
(UNPACK (CAR FARGS1)))
(SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS1)))
(SETQ FARGS1 (CDR FARGS1)))
(T (SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS2)))
(SETQ FARGS2 (CDR FARGS2)))))))
(SETQ FARGS TEMPFARGS)
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT (MEMBER
COMMENT
(SETQ CFLAT (FLATTEN CODE))))
))))
(MEMBER (QUOTE ARG3)
CFLAT))
(DETERMINE:ARG3:VALUE CHOICE)
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
(@ ARG3))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT CFLAT)))))
(MEMBER (QUOTE ARG2)
CFLAT))
(DETERMINE:ARG2:VALUE CHOICE)
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
(@ ARG2))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG1 FRAG1)
(MEMBER COMMENT CFLAT)))
(MEMBER (QUOTE ARG1)
CFLAT))
(DETERMINE:ARG:VALUE CHOICE)
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
(@ ARG1))
CODE))))
(EVAL (LIST (QUOTE DEFINEQ)
(LIST FNAME (APPEND (LIST (COND ((GETP BNAME NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (COND (FARGS)
(T NIL)))
CODE))))
(PRIN1 "
PUP NOW DEFINES THIS FUNCTION:
")
(PRETTYPRINT (LIST FNAME))
(LIST (VECTOR WE DEFINE THE FUNCTION (@ FNAME)
AS:
(INVECTOR CODE))))
POST:REQUISITES ((VECTOR IS BEING FNAME))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN (((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL NUCLEUS OF RELEVANT INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE IRRELEVANT INFO FROM (@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF INFO IS RELEVANT TO ANY SPECIFIC PROBLEM, AND PUP
CANNOT HANDLE A LARGE MASS OF INFO EFFICIENTLY)
WHEN (((GREATERP (SIZE NEW:INFO)
50)
70
(QUOTE (BECAUSE IF THE NEW INFO IS OVER 50 TOKENS LONG, THEN WE CANNOT
EFFICIENTLY COMPREHEND IT)))
((LESSP (SIZE NEW:INFO)
12)
-80
(QUOTE (BECAUSE IF THE NEW INFO IS LESS THAN A DOZEN TOKENS LONG THEN WE
SHOULD EASILY BE ABLE TO PROCESS IT AS IT IS))))
META:CODE (PROGN (USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(VECTOR RELEVANT NEW:INFO))
(SETQ RELEVANT:INFO:LIST (CONS NEW:INFO RELEVANT:INFO:LIST)))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO NEW:INFO:LIST)
MAIN:EFFECTS (((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1))))
AFFECTS (QUOTE ((APPLY:PROGRAMMING:KNOWLEDGE CALLED)))
COMPLEXITY:VECTOR (.3 .6 .6 .5 .1))
(PUTPROPS FILL:IN:UNDEFINED:SECTION BEING T
IDEN (((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI))))
IMPLICIT:ARGS (CHOICE)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK UNDEFINED:SECTION:LIST
WHAT (VECTOR FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM
(@ PROGRAM))
HOW (VECTOR CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
WHY (VECTOR BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
WHEN ((UNDEFINED:SECTION:LIST 80
(TUPLE BECAUSE UNDEFINED:SECTION:LIST CONTAINS
PIECES OF CODE AS YET UNDEFINED))
((NULL UNDEFINED:SECTION:LIST)
-1000
(TUPLE BECAUSE NO PIECES OF CODE ARE KNOWN AND YET NOT YET DEFINED))
((SETINTERSECTION ENCODABLE:SECTION:LIST UNDEFINED:SECTION:LIST)
96
(TUPLE BECAUSE WE KNOW ENOUGH TO CODE EACH OF THE FOLLOWING SECTIONS:
(INVECTOR (SETINTERSECTION UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST)))))
META:CODE (COND ((SETQ NEW:PIECE (ENCODE CHOICE))
(SETQ UNDEFINED:SECTION:LIST (PULLOUT CHOICE
UNDEFINED:SECTION:LIST))
(COND ((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ UNDEFINED:SECTION:LIST (PULLOUT (LIST VECTOR ANY2)
UNDEFINED:SECTION:LIST))))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT CHOICE
ENCODABLE:SECTION:LIST))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SET PROGRAM (APPEND (EVAL PROGRAM)
NEW:PIECE)))
(T (SETQ DOING:PUP:LIST (CDDR DOING:PUP:LIST))
(SETQ PUP:WANTS:LIST (CONS (VECTOR MORE INFO RELEVANT TO
MAKING (@ CHOICE)
CODABLE)
PUP:WANTS:LIST))
NIL))
COMMENTS ((SETQ OLD:DO:LIST DOING:PUP:LIST)
(SETQ CHOICE (INVECTOR (MINIMUM (COND ((SETINTERSECTION
UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST))
(T UNDEFINED:SECTION:LIST))
FAST:BEING:COMPLEX)))
(SETQ DOING:PUP:LIST (CONS CHOICE DOING:PUP:LIST))
(SATISFY
(VECTOR
TYPE OF
(VECTOR
(SETQ
XTHING
(VECTOR
(PROG1 (COND ((ATOM CHOICE)
(SETQ TC CHOICE))
((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ TC ANY1)
ANY2)
(T (SETQ TC (CAR (OUTVECTOR CHOICE)))))
(SETQ DOING:PUP:LIST
(CONS (INVECTOR (SASSOC TC (OUTVECTOR
FN:CALL:LIST)))
DOING:PUP:LIST))
(MAPC (CDR (SASSOC TC (OUTVECTOR FN:CALL:LIST)))
(FUNCTION
(LAMBDA (AA)
(COND
((ATOM AA)
(SATISFY
(VECTOR TYPE OF
(VECTOR (LIST VECTOR AA)
HAS BEEN STUDIED))
)))))))))
HAS BEEN STUDIED))
(AND (NOT (CAR (NLSETQ (SASSOC TC (OUTVECTOR OLD:DO:LIST)))))
(SOME TYPE:OF:LIST (FUNCTION
(LAMBDA (TOLL)
(AND (MATCH (VECTOR ANY1 TYPE OF (@ XTHING)
FRAG1)
TOLL)
(NOT (EQUAL ANY1 TC))))))
T)))
AFFECTS (QUOTE ((ENCODE CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS GET:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE GET (@ ENTITY)
INTO PUP'S AWARENESS)
HOW (TUPLE SEE IF (@ ENTITY)
IS ALREADY KNOWN; IF NOT, TRY TO COMPUTE IT; IF THIS ALSO FAILS, ASK THE USER ABOUT
IT)
WHY (TUPLE PUP NEEDS (@ ENTITY)
AT THIS POINT IN TIME)
META:CODE (OR (TAKE:HOLD:OF ENTITY)
(ASK:USER:ABOUT ENTITY))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NLAMBDA T
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM ALREADY EXIST WHICH GETS
PRECISELY (@ ARG1))
AFFECTS
(VECTOR WHETHER WE CAN STOP THE GETTING ACTIVITY AND -- INSTEAD
-- WORK ON IMPLEMENTING)
WHEN
(VECTOR BEFORE ANY MORE ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE WE MAY NOT REALLY WANT A GETTING ROUTINE AFTER
ALL; WE MAY INSTEAD WANT AN IMPLEMENTING TYPE OF
ROUTINE.)
GET:HOLD:OF)
(VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM EXIST WHICH GETS
(@ ARG1)
AND PERHAPS SOME OTHER STUFF)
AFFECTS
(VECTOR WHETHER WE CAN STOP TRYING TO 'GET' AND INSTEAD TRY TO
'IMPLEMENT')
WHEN
(VECTOR BEFORE ANY GET:HOLD:OF ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE TO DO SO EARLIER WOULD PRECLUDE THE CHANCE OF A
TRIVIAL SOLUTION TO THE GETTING; TO DO SO LATER MIGHT
CAUSE UNNECESSARY CODE TO BE WRITTEN)
GET:HOLD:OF)
(VECTOR ALTERNATIVES (VECTOR NO:ERROR:RECOVERY BACKTRACK:ERROR:RECOVERY
CORRECT:ERROR:AND:PROCEED:ERROR:RECOVERY)
AFFECTS
(VECTOR STORAGE OF INTERMEDIATE RESULTS)
WHEN
(VECTOR AFTER ALL GET:HOLD:OF ROUTINES ARE FINALIZED)
GET:HOLD:OF)
(VECTOR SOMEOF (VECTOR COMPUTE SEARCH GENERATE:AND:TEST)
COMMENT
(VECTOR THE SEARCH REFERS TO A KNOWN, FINITE SPACE; THE
GENERATE AND TEST REFERS TO AN UNKNOWN, INFINITE SET)
AFFECTS
(VECTOR THE GET:HOLD:OF ALGORITHM)
GET:HOLD:OF)))
(PUTPROPS GET:NAME BEING T
IDEN (((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI))))
IMPLICIT:ARGS (TEMP1 NE EV:NEW:NAME)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER TO (@ EXPRESSION))
WHEN ((T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE NO MORE AND NO LESS THAN ONE NAME))))
META:CODE (COND ((OR (NUMBERP (CAR (LAST (COLON:BREAK EV:NEW:NAME))))
(AND (MATCH (VECTOR ANY2)
EXPRESSION)
(NUMBERP (CAR (LAST (COLON:BREAK (CADR EXPRESSION)))))))
(PRIN1
"
HMMMMM..... IT SEEMS I'VE SEEN THIS IDENTIFIER BEFORE. I WON'T NEED
YOUR INTERACTION AFTER ALL. SORRY TO TROUBLE YOU.
")
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((ATOM (EVAL NEW:NAME))
(EVAL NEW:NAME))
(T (CADR (EVAL NEW:NAME))))
(CADR EXPRESSION))
(SETQ OLDNAME:TAG T)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))
(T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
(TERPRI)
(PRIN1 (CONCAT "IS THIS THE SAME AS A " EXPRESSION
" WHICH WE'VE ALREADY SEEN AND NAMED?
USER: "))
(SETQ TEMP1 (MEMBER (READ)
(QUOTE (Y YES MAYBE))))))
(COND (TEMP1 (SETQ NE (INTERSECTION (SETQ
TEMPINT
(MAPCONC
TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(@ EXPRESSION)
FRAG1)
TOL)
(LIST ANY1)))))))
TEMPINT))))
(COND ((CDR NE)
(PRIN1 (CONCAT NE
" ARE SUCH NAMES. SINCE THERE IS MORE THAN ONE, PLEASE TYPE IN TO ME THE NAME (AGAIN) OF O THE ABOVE,
OR TYPE <CR> IF THE NAME YOU WANT ISNT REALLY ONE OF THESE AFTER ALL.
USER: SINCE"))
(SETQ TEMP1 (READ)))
(NE (PRIN1 (CONCAT "SINCE " (CAR NE)
" IS THE ONLY NAME FOR " EXPRESSION
",
AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
YOU WANT. AM I RIGHT?
USER: "))
(SETQ TEMP1 (COND ((MEMBER (READ)
(QUOTE (Y YES)))
(CAR NE)))))
(T (PRIN1 (CONCAT "I DON'T KNOW ANY NAMES FOR " EXPRESSION
", SO YOU'LL HAVE TO
TYPE A BRAND NEW NAME IN TO ME. "))
(TERPRI)
(SETQ TEMP1 NIL)))
(COND (TEMP1 (SETQ OLDNAME:TAG T)
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TEMP1))
(T (PRIN1 "USER: ")
(SETQ TREAD (READ))
(SETQ TREAD (COND (TREAD)
((COLON:BACK (OUTVECTOR (OUTNIL (FLATTEN EXPRESSION))
)))))
(COND ((NOT (OR (MEMBER TREAD PRIMITIVE:PROGRAMS:LIST)
(NUMBERP (CAR (LAST (COLON:BREAK TREAD))))))
(SETQ TREAD (PACK (TUPLE (@ TREAD)
:
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER))
)))))
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TREAD)
(SET TREAD TREAD)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))))
)
COMMENTS ((COND ((NOT (ATOM NEW:NAME))
(SETQ NEW:NAME (CADR NEW:NAME)))
(T T))
(SETQ EV:NEW:NAME (COND ((ATOM NEW:NAME)
NEW:NAME)
(T (EVAL NEW:NAME)))))
PRE:REQUISITES ((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR (@ EXPRESSION)))
(VECTOR AWARE USER (VECTOR PUP WANTS USER TO TYPE IN NAME FOR (@ EXPRESSION))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP AND USER ARE ABLE TO REFER TO (@ EXPRESSION)
AS
(@ NEW:NAME)
WHICH IS (EVAL NEW:NAME))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2))))
COMPLEXITY:VECTOR (.1 .3 .2 .5 .1))
(PUTPROPS GET:NEW:INFORMATION IDEN (((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF INFORMATION AND CALL IT (@ NEW:INFO))
HOW (TUPLE ASK THE USER FOR NEW INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE ESPECIALLY SPEC:WHY)
WHEN ((T (COND (NEW:INFO:LIST -68)
(T 50))
(QUOTE (BECAUSE WE SHOULD GET NEW INFORMATION IFF THERE IS NONE IN EXISTENCE)))
)
META:CODE (PROG1 (COND ((ATOM NEW:INFO)
(SET NEW:INFO (INVECTOR (READ))))
(T (SET (EVAL NEW:INFO)
(INVECTOR (READ)))))
(SETQ NEW:INFO:LIST (CONS (EVAL NEW:INFO)
NEW:INFO:LIST))
(SETQ PUP:WANTED:LIST (CONS (CAR PUP:WANTS:LIST)
PUP:WANTED:LIST))
(SETQ PUP:WANTS:LIST (CDR PUP:WANTS:LIST)))
COMMENTS ((PRIN1 "
USER: ")) PRE:REQUISITES ((VECTOR AWARE USER (APPEND (QUOTE (VECTOR PUP WANTS))
(CDAR PUP:WANTS:LIST))))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1))))
COMPLEXITY:VECTOR (.1 .1 .1 .5 .1))
(PUTPROPS IS:OF:TYPE BEING T
EXPLICIT:ARGS (OBJECT SPECIAL:KNOWLEDGE)
EXPLICIT:ARGS:CHECK (MATCH (TUPLE COMMENT FRAG1)
SPECIAL:KNOWLEDGE)
WHAT (TUPLE SEE IF (@ OBJECT)
IS OF THE TYPE SPECIFIED. THE PARTICULAR TYPE IS DELINEATED BY THE SPECIAL KNOWLEDGE
(@ SPECIAL:KNOWLEDGE))
HOW (TUPLE USE (@ SPECIAL:KNOWLEDGE)
DETAILS TO SEE IF IT CONTAINS (@ OBJECT))
WHY (TUPLE WE MUST BE ABLE TO TEST AN OBJECT (@ OBJECT)
AND SEE IF IT BELONGS TO THE TYPE (@ SPECIAL:KNOWLEDGE))
META:CODE (PROGN (ASK:USER:ABOUT OBJECT))
COMPLEXITY:VECTOR (.35 .35 .35 .35 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION
(VECTOR HOW DO WE KNOW WHEN THE 'IS:OF:TYPE' PREDICATE IS TRUE,
AND WHEN IT IS FALSE? PUP ASSUMES THAT USER WILL TYPE IN
A LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT TO IT)
AFFECTS
(VECTOR CODE INVOLVING IS:OF:TYPE)
IS:OF:TYPE)))
(PUTPROPS MAKE:ENCODABLE BEING T
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR TRY TO MAKE (@ B:CALL)
ENCODABLE)
HOW (TUPLE FIRST SEE IF IT ALREADY IS; IF NOT, TRY TO USE DOMAIN:DEPENDENT KNOWLEDGE)
WHY (TUPLE BECAUSE (@ B:CALL)
MUST EVENTUALLY GET ENCODED)
MAIN:EFFECTS (((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1))))
META:CODE (OR (AND (ATOM B:CALL)
(GETP B:CALL ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
TYPE OF (CAR (GETP B:CALL
GENERALIZATIONS))
IS
(INVECTOR (GETP B:CALL META:CODE)))
TYPE:OF:LIST)))
(AND (MATCH (VECTOR ANY1 TYPE OF ANY2 FRAG1)
B:CALL)
(SETQ ANY1:HOLD ANY1)
(SETQ ANY2:HOLD ANY2)
(COND ((MAKE:ENCODABLE ANY1))
((GETP ANY2:HOLD ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ ANY1:HOLD)
TYPE OF (@ ANY2:HOLD)
IS
(INVECTOR (GETP ANY2:HOLD
META:CODE)))))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS MAKE:NEW:BEING BEING T
EXPLICIT:ARGS (FNAME)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR GIVE BIRTH TO THE NEW BEING (@ FNAME))
HOW (VECTOR FILL IN EACH PART OF A BEING, FOR THE BEING (@ FNAME))
WHY (VECTOR (@ FNAME)
MUST EXIST TO BE UNDERSTOOD)
MAIN:EFFECTS (((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1))))
META:CODE (PROGN (SET FNAME FNAME)
(SETQ YY WRITE:PROGRAM)
(SETQ IS:BEING:LIST (CONS FNAME IS:BEING:LIST))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (BP)
(COND ((GETP BNAME BP)
(PUT FNAME BP
(GETP BNAME BP)))))))
(PUT FNAME BEING T)
(PUT FNAME IDEN (SUBST FNAME BNAME (COPY (GETP FNAME IDEN))))
(ADD:IDEN FNAME)
(PUT FNAME MAIN:EFFECTS (SUBST FNAME BNAME (COPY (GETP FNAME MAIN:EFFECTS)))
)
(ADD:EFFECTS FNAME)
(PUT FNAME EXPLICIT:ARGS (SETUNION FARGS (GETP BNAME EXPLICIT:ARGS)))
(PUT FNAME WHAT (VECTOR A SPECIALIZED BEING WHICH DOES (GETP BNAME WHAT)))
(PUT FNAME WHY (APPEND (GETP FNAME WHY)
(TUPLE AND (@ BNAME)
IS TOO GENERAL TO USE AS IT IS)))
(PUT FNAME META:CODE (COND ((LESSP (LENGTH CODE)
2)
(CAR CODE))
(T (CONS (QUOTE PROGN)
CODE))))
(PUT FNAME GENERALIZATIONS (CONS BNAME (GETP FNAME GENERALIZATIONS)))
(PUT FNAME AFFECTS (PROG (X)
(SETQ X (VECTOR))
(MAPC (FLATTEN CODE)
(FUNCTION
(LAMBDA (CC)
(COND
((GETP (CAR (COLON:BREAK CC))
BEING)
(SETQ
X
(NCONC1 X
(VECTOR (@ CC)
POSSIBLE
CALLED)))
(SETQ YY (CONS CC YY)))))))
(RETURN X)))
(PUT FNAME SPECIALIZATIONS NIL)
(PUT FNAME COMPLEXITY:VECTOR (VECTOR:AVERAGE YY))
(SEMI:COMPILE FNAME)
T)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS MESSAGE IDEN (((@ (AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2)))
(VECTOR MESSAGE (CADR LI)))
((@ (MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI))
(VECTOR MESSAGE (INVECTOR FRAG1))))
BEING T
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL READ THE MESSAGE (@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE INFORMATION IN THE MESSAGE (@ M))
WHEN (((MEMBER M AWARE:USER:LIST)
-201
(QUOTE (BECAUSE THE USER NEVER FORGETS))))
META:CODE (PROGN (TERPRI)
(PRIN1 "PUP: ")
(PRINT (OUTVECTOR M))
(TERPRI)
(SETQ AWARE:USER:LIST (CONS M AWARE:USER:LIST))
(SETQ FRINGE:CONCIOUS:LIST (LIST M (CAR FRINGE:CONCIOUS:LIST)))
(SETQ LASTRESPONDER (QUOTE PUP))
(SETQ READ:USER:LIST (CONS M READ:USER:LIST)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1))))
MINOR:EFFECTS ((QUOTE (LASTRESPONDER PUP)))
COMPLEXITY:VECTOR (0.0 .1 .9 .7 .1)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY))
(PUTPROPS METRICAL:CONCEPT:FORMATION BEING T
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION)
(METRIZE ORDER))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN (((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME INFORMATION WHICH CAN BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT OLD INFORMATION, OR OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE INFORMATION THAT IT CAN USE TO PROGRESS)
WHEN ((T -10 (TUPLE SINCE THIS IS AN EXPONENTIALLY-GROWING, BAD THING TO DO IN
GENERAL))
(NEW:INFO:LIST 111
(QUOTE (BECAUSE WE SHOULD WORK ON UNASSIMILATED NEW
INFORMATION IF THERE IS ANY))))
META:CODE (PROGN (SETQ BECAUSE
(QUOTE (VECTOR WE CAN ONLY TRY TO OBTAIN USABLE
INFORMATION IN ONE WAY AT A TIME)))
(CHOOSE:FROM (QUOTE ((TRANSLATE U)
(GET:NEW:INFORMATION U)
(ANALYZE:IMPLICATIONS U)
(EXTRACT:RELEVANT:SUBSET U)))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1))))
AFFECTS (QUOTE ((CHOOSE:FROM CALLED)
(TRANSLATE POSSIBLE:CALLED)
(GET:NEW:INFORMATION POSSIBLE:CALLED)
(ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:A:DOMAIN BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (COMMENT WE SHOULD NEVER REALLY BE HERE, SINCE THIS IS ALWAYS DONE BY A
COLLECTION OF THE THREE METHODS OF PARTITIONING DISCUSSED IN
THE 'SPECIALIZATIONS' SECTION)
(SETQ PARTITIONED:DOMAIN:LIST T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY PARTIAL)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
ZERO CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY WEAK)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
MANY CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR SOMEOF (VECTOR PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:GET:CLASS)
AFFECTS
(VECTOR THE PARTITION:A:DOMAIN ALGORITHM)
PARTITION:A:DOMAIN))
IDEN (((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN)))
WHAT (TUPLE DIVIDE A DOMAIN INTO SUBDOMAINS; USUALLY THESE WILL BE DISJOINT, AND THEIR
UNION WILL BE THE ENTIRE DOMAIN)
HOW (TUPLE BY BUILDING UP THE PARTITION GRADUALLY, BY ADDING TO OUR KNOWLEDGE OF THE
PARTITION ONE PAIR AT A TIME; HERE A PAIR IS <ELEMENT, CLASS:NAME>)
WHY (TUPLE BECAUSE PUP MUST ENCODE A FUNCTION WHICH PARTITIONS A DOMAIN INTO CLASSES)
MAIN:EFFECTS (((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN)))
WHEN ((PARTITIONED:DOMAIN:LIST -100 (TUPLE BECAUSE WE ALREADY HAVE PARTITIONED DOMAIN))
((NULL PARTITIONED:DOMAIN:LIST)
20
(TUPLE BECAUSE PUP HAS NOT YET PARTITIONED DOMAIN, SO IT IS PLAUSIBLE TO DO IT
NOW)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON)
GENERALIZATIONS (TUPLE MAP BUILD:FUNCTION)
ALTERNATIVES (TUPLE DIVIDE:UP DISCRETIZE))
(PUTPROPS PARTITION:BY:TAKE:CLASS:GET:ELE BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (TAKE:HOLD:OF NAME:OF:CLASS)
(GET:HOLD:OF ELEMENT))
GENERALIZATIONS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:BY:TAKE:ELE:AND:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENTS AND THEIR
ASSOCIATED CLASS NAMES)
HOW (TUPLE READ IN PAIRS OF ELEMENT:CLASS)
WHY (TUPLE PARTITION IS DEFINED AS A SET OF ORDERED PAIRS)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(TAKE:HOLD:OF NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:BY:TAKE:ELE:GET:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENT AND
DETERMINING THE CLASS IT BELONGS TO)
HOW (TUPLE READ IN ELEMENT, DEDUCE ITS CLASS)
WHY (TUPLE TO SHOW THAT THE PARTITIONING IS BEING DONE CORRECTLY)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(GET:HOLD:OF NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN (((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI))))
IMPLICIT:ARGS (EXPRES2 NEW:EXPRES)
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK (COND ((ATOM EXPRES)
(SETQ NEW:EXPRES (COLON:BREAK EXPRES)))
(T (SETQ NEW:EXPRES
(PROG (TEMP1)
(MAPC EXPRES (FUNCTION
(LAMBDA (ZZ)
(SETQ TEMP1
(APPEND
TEMP1
(COLON:BREAK
ZZ))))))
(RETURN TEMP1)))))
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO EXTRACT MNEMONIC CONTRACTIONS OF (@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN CHOOSING A EXPRES FOR THE OBJECT (@ EXPRES))
MAIN:EFFECTS (((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1))))
WHEN ((T (COND ((MEMBER (TUPLE PLAUSIBLE NAMES FOR (@ EXPRES))
PUP:STUDIED:LIST)
-99)
(T 33))
(QUOTE (BECAUSE WE SHOULDNT WASTE TOO MUCH TIME GETTING PLAUSIBLE NAMES,
YET WE ALSO SHOULDNT COMPLETELY LET THE USER FEND FOR
HIMSELF ON THIS SUBJECT))))
META:CODE (PROG (P)
(SETQ EXPRES2 (OUTVECTOR (OUTQUOTE NEW:EXPRES)))
(SETQ P (MAPCAR (LIST (INITIALS EXPRES2)
(MAIN:WORDS EXPRES2)
(FIRST:FEW (INITIALS EXPRES2))
(FIRST:FEW (MAIN:WORDS EXPRES2))
(FIRST:FEW (INITIALS (MAIN:WORDS EXPRES2)))
(LIST (PACK (INITIALS EXPRES2)))
(LIST (PACK (FIRST:FEW (INITIALS EXPRES2)))))
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE P KNOWN:NAMES))
(SETQ P (INTERSECTION P P))
(SETQ MSG (VECTOR (@ P)
IS THE SET OF PLAUSIBLE NAMES OF (@ EXPRES2)
WHICH IS AN EXPANSION OF (@ EXPRES)))
(SETQ PLAUSIBLE:NAMES:LIST (CONS (VECTOR FOR (@ EXPRES)
HAVE BEEN STUDIED)
PLAUSIBLE:NAMES:LIST))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR PLAUSIBLE NAMES FOR
(@ EXPRES))
PUP:STUDIED:LIST))
(RETURN P))
POST:REQUISITES ((VECTOR AWARE USER (INVECTOR MSG)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON)
COMPLEXITY:VECTOR (.1 .2 .3 .5 .1))
(PUTPROPS REINVESTIGATE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (OR (MEMBER D DEFERRED:DECISION:LIST)
(EQUAL (CADDDR D)
(VECTOR BECAUSE OF DIRECT COMMAND)))
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE; FIRST TRY TO DEFER IT A LITTLE LONGER)
HOW (VECTOR TRY TO DEFER (CADDR D)
;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;ELSE ASK THE USER TO
RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADDR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D)))))
META:CODE (PROGN (SETQ DEFERRED:DECISION:LIST (PULLOUT D DEFERRED:DECISION:LIST))
(SETQ UNDEFERRED:DECISION:LIST (CONS (CADR D)
UNDEFERRED:DECISION:LIST))
(DEFER:DECISION (CADR D)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS REPEATEDLY BEING T
EXPLICIT:ARGS (ACT1 ACT2 ACT3 ACT4)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE DO ACTIONS OVER AND OVER)
HOW (TUPLE CONVERT THE SINGLE FUNCTION CALL INTO AN INFINITE ITERATIVE LOOP)
WHY (TUPLE THIS IS EASIER, SURER, AND OFTEN FASTER THAN RECURSION)
META:CODE (PROGN (VECTOR SEE THE FORM:CHANGING SECTION)
(SETQ F1 (APPEND (TUPLE REPEATEDLY)
ACT1 ACT2 ACT3 ACT4))
(EVAL (GETP REPEATEDLY FORM:CHANGING)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FORM:CHANGING (PROGN (SETQ F1 (APPEND (TUPLE PROG NIL (SETQ TEMPL (COLON:BACK
(TUPLE LABEL (SETQ LABEL:COUNTER
(ADD1
LABEL:COUNTER)))))
)
(CONS (PROG1 (SETQ C1 (GETCODE (CADR F1)
FNAME 0))
(COND ((NUMBERP (CAR (LAST (COLON:BREAK
C1))))
(SETQ
FN:CALL:LIST
(CONS (INVECTOR (CONS C1
(CDDR F1)))
FN:CALL:LIST)))))
(GETCODE (CDDR F1)
FNAME 1))
(TUPLE (LIST GO TEMPL)
(TUPLE COMMENT INFINITE LOOP IN THIS PROG))))
(SETQ CODING:WARNING:LIST (CONS (VECTOR INFINITE LOOP IN (@ FNAME)
FROM
(@ TEMPL)
TO
(LIST VECTOR GO TEMPL))
CODING:WARNING:LIST))
F1))
(PUTPROPS RESOLVE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1 ENT2 ENT1 TRESULT NEWPIECE)
EXPLICIT:ARGS (D STAG)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE)
HOW (VECTOR TRY TO RESOLVE (CADR D)
WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK THE USER ABOUT IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND)))))
META:CODE (COND ((MEMBER (CADR D)
RESOLVED:DECISION:LIST)
T)
(T (SETQ RESOLVED:DECISION:LIST (CONS (VECTOR (CADR D)
IS RESOLVED AS
(INVECTOR (ASK:USER:ABOUT
D)))
RESOLVED:DECISION:LIST))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SATISFY IDEN (((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T))))
IMPLICIT:ARGS (TEMP:LIST EV:G)
EXPLICIT:ARGS (G FORCE:SAT)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL (@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
META:CODE (COND ((AND (MEMBER EV:G (EVAL (SETQ TEMP:LIST (COLON:BACK (COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST)))))))
(NOT FORCE:SAT)))
(T (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA (E1)
(COND
((MATCH (CAR E1)
G)
(SETQ B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(SETQ BECAUSE
(VECTOR WE CALL THE SIMPLEST BEING WHICH CAN BRING ABOUT THE EFFECT
(@ G)))
(COND (B:LIST (RETURN (PROG (CB:LIST)
(SETQ CB:LIST (COPY (MAPCAR B:LIST
(QUOTE CDR))))
(SETQ CB:LIST (INTERSECTION CB:LIST CB:LIST))
(SORT CB:LIST A:BEING:ORDER)
LABEL5
(SETQ POS:B (CAR CB:LIST))
(EVAL POS:B)
(COND ((MEMBER EV:G (EVAL TEMP:LIST))
(RETURN (SETQ PUP:SATISFIED:LIST
(CONS G
PUP:SATISFIED:LIST))))
((CDR CB:LIST)
(SETQ CB:LIST (CDR CB:LIST))
(GO LABEL5))
(T (PRIN1
"
WARNING: SATISFY IS SHAKING ITS HEAD ABOUT THIS ONE:")
(PRIN1 G)
(RETURN NIL))))))
(T (RETURN NIL))))))
COMMENTS ((SETQ G (EVAL G))
(SETQ EV:G (EVAL (CADDDR G))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1))))
AFFECTS (APPEND (MAPCAR (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA
(E1)
(COND ((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(RETURN B:LIST))
(FUNCTION (LAMBDA (Y)
(COND (Y (CONS Y (QUOTE (POSSIBLE:CALLED))))))))
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED))))
COMPLEXITY:VECTOR (0.0 .3 .2 .4 .1)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM ADAPT:PRECONCEIVED:FUNCTION)
BEING T
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SCENE BEING T
META:CODE (STRUCTURE (OBJECTS SET O)
(CLASS:NAME NAME N)
(STATIC RELATIONS S BETWEEN OBJECTS)
(DYNAMIC RELATIONS D BETWEEN OBJECTS))
IDEN (((EQUAL LI (LIST SCENE))
(VECTOR SCENE)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
DATA:STRUCTURE T)
(PUTPROPS SERVE IDEN (((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE)))
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
META:CODE (PROG (UNKNOWN:TASK)
(SETQ UNKNOWN:TASK NON:EXECUTABLE)
(SETQ BECAUSE (VECTOR THE CURRENT TASK (@ UNKNOWN:TASK)
IS NOT EXECUTABLE AND WE HAVE NOTHING ELSE TO DO AT THE PRESENT
TIME))
LABEL6
(COND ((NOT (MEMBER UNKNOWN:TASK EXECUTABLE:INFO:LIST))
(MAPC USER:INTERRUPT:DEMONS (QUOTE APPLY*))
(OBTAIN:USABLE:INFORMATION (QUOTE UNKNOWN:TASK))
(GO LABEL6)))
(SETQ ATTEMPTING:SOMETHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:SOMETHING:LIST))
(SETQ ATTEMPTING:ANYTHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:ANYTHING:LIST))
(SETQ BECAUSE (VECTOR WE FINALLY HAVE AN EXECUTABLE TO TASK TO DO, NAMELY
(@ UNKNOWN:TASK)))
(SETQ EXECUTABLE:INFO:LIST NIL)
(EVAL (CDR UNKNOWN:TASK)))
COMMENTS ((SETQ PUP:WANTS:LIST (CONS (VECTOR ANY TASK)
PUP:WANTS:LIST)))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WANTS ANY TASK)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE)))
COMPLEXITY:VECTOR (.2 .4 .6 .8 .1)
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
DEMONS (TUPLE FORGETFUL:USER:DEMON))
(PUTPROPS STUDY:TYPE BEING T
IDEN (((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI))))
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK (GETP (CADR B:CALL)
BEING)
WHAT (TUPLE INVESTIGATE THE VARIOUS SPECIALIZATIONS OF (@ B:CALL))
HOW (TUPLE TRANSFER THE SPECIALIZATIONS (GETP (CADR B:CALL)
SPECIALIZATIONS)
OF
(@ B:CALL)
ONTO THE LIST OF DECISIONS WHICH MUST BE ATTENDED TO)
WHY (TUPLE BECAUSE THE MORE SPECIFIC OUR KNOWLEDGE OF WHAT IS WANTED, THE MORE EASILY AND
COMPLETELY WE MAY SATISFY THAT REQUEST)
MAIN:EFFECTS (((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1))))
META:CODE (PROGN (MAPC (CDR (GETP (CADR B:CALL)
SPECIALIZATIONS))
(FUNCTION (LAMBDA (A)
(SETQ UNDEFERRED:DECISION:LIST
(NCONC1 UNDEFERRED:DECISION:LIST
(COND ((ATOM A)
A)
((ATOM (CAR A))
(EVAL A))
((APPLY* (EVAL (CAR A))
B:CALL))))))))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR TYPE OF (@ B:CALL))
PUP:STUDIED:LIST))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
HAS BEEN STUDIED)
TYPE:OF:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS TAKE:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TAKE THE ENTITY (@ ENTITY)
IN A TRIVIAL WAY; EITHER BY ACCESSING IT OR BY READING IT IN)
HOW (TUPLE LOOK AROUND A LITTLE; IF IT ISNT FOUND TRIVIALLY, THEN ASK THE USER TO GIVE
(@ ENTITY)
TO US)
WHY (TUPLE PUP WANTS (@ ENTITY)
,AND WE DON'T HAVE TO DO ANY COMPUTING TO GET IT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(QUOTE (AND (FLOW:PRECEDED (VECTOR SETQ (@ ARG1)
ANY1))
(PRINT (TUPLE THE ASSIGNMENT WHICH SET (@ ARG1)
,NAMELY
(@ FLOW:ASSIGNMENT)
,WAS DONE EARLIER; SHOULD A NEW VALUE OF
(@ ARG1)
BE READ IN AT THIS POINT IN THE PROGRAM FLOW?
USER...))
(MEMBER (READ)
(QUOTE (N VECTOR NO NIL)))))
AFFECTS
(VECTOR THE TAKE:HOLD:OF ALGORITHM)
RESULTS
(VECTOR
(COMMENT DO NOTHING SINCE WE ALREADY HAVE WHAT WE WANT)
(QUOTE (APPEND (LIST (VECTOR SET ARG1 (TUPLE READ)))
(MAPCAR (CDR (GETP (EVAL ARG1)
META:CODE))
(FUNCTION
(LAMBDA
(EPART TCODE)
(SETQQ NEWNAME NEWNAME)
(PRINT (TUPLE PUP IS ABOUT TO ENCODE AN
ASSIGNMENT: (@ EPART)
WILL BE SET TO SOME PART OF
ARG1 WHICH IS GOING TO BE
INSTANTIATED DURING THE RUNNING
OF THE PROGRAM AS (EVAL ARG1)
.PUP WANTS A NAME FOR THIS
'SOME PART OF' FUNCTION.))
(SETQ ARG:LIST (CDR (SASSOC (CADR CHOICE)
(OUTVECTOR
FN:CALL:LIST))))
(SETQ TCODE
(GETCODE (TUPLE SETQ (COLON:BACK EPART)
(TUPLE SOME:PART:OF
ARG1))
(CAR (LAST (CADR D)))
-1))
(SETQ NEW:THING:LIST (CONS (CADR TCODE)
NEW:THING:LIST))
(SETQ
TYPE:OF:LIST
(CONS (VECTOR (CADR TCODE)
TYPE OF (CONS VECTOR EPART)
IS USED IN THE ASSIGNMENT
STATEMENT (@ TCODE)
IN
(CAR (LAST (CADR D))))
TYPE:OF:LIST))
TCODE)))
(PROGN (SETQ NEW:THING:LIST (CONS (EVAL ARG1)
NEW:THING:LIST))
(LIST T)))))
TAKE:HOLD:OF))
NLAMBDA T)
(PUTPROPS TRANSLATE IDEN (((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO FORCE:TRANSLATE)
WHAT (TUPLE TRANSLATE A PIECE OF UNTRANSLATED NEW INFORMATION)
HOW (TUPLE TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (TUPLE EW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE PROCEDURAL BEFORE IT MAY BE USED BY THE SYSTEM)
WHEN ((T (COND (USABLE:INFO:LIST -60)
(T 50))
(QUOTE (BECAUSE THE ABSENCE OF USABLE INFORMATION ABDUCTIVELY CALLS FOR ITS PRODUCTION;
ITS PRESENCE DEMANDS ITS ASSIMILATION)))
((MEMBER (EVAL NEW:INFO)
TRANSLATED:INFO:LIST)
-111
(VECTOR BECAUSE WE HAVE ALREADY TRANSLATED IT IMPLIES WE SHOULDNT NOW)))
META:CODE (PROG (LI TEMPTR)
(SETQ LI (CDR EV:NEW:INFO))
(SETQ NEW:INFO:LIST (PULLOUT EV:NEW:INFO NEW:INFO:LIST))
(MAPC IDEN:TABLE (FUNCTION (LAMBDA (II)
(COND ((EVAL (CAR II))
(COND ((SETQ TEMPTR
(EVAL (CADR II)))
(SETQ TRANSLATED:PAIR:LIST
(CONS (LIST EV:NEW:INFO
TEMPTR)
TRANSLATED:PAIR:LIST)
)
(SETQ TRANSLATED:INFO:LIST
(CONS EV:NEW:INFO
TRANSLATED:INFO:LIST))
(COND ((NOT FORCE:TRANSLATE)
(SETQ
EXECUTABLE:INFO:LIST
(CONS TEMPTR
EXECUTABLE:INFO:LIST)))))
)
(RETURN TEMPTR))))))
(PRIN1 "SORRY, I T TRANSLATE
PLEA
PLEA")
(PRIN1 "
PLEASE RETYPE THE FOLLOWING, REPHRASING IT SO I CAN COMPREHEND IT:
")
(PRIN1 EV:NEW:INFO)
(RETURN (TRANSLATE (INVECTOR (READ))
T)))
EXPLICIT:ARGS:CHECK (OR (MEMBER (EVAL NEW:INFO)
NEW:INFO:LIST)
(NULL (EVAL NEW:INFO))
FORCE:TRANSLATE
(COND (NEW:INFO:LIST (SETQQ NEW:INFO UNKNOWN:TASK)
(SET NEW:INFO (CAR NEW:INFO:LIST)))))
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS (((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1))))
MINOR:EFFECTS ((VECTOR NEW INFO))
AFFECTS (QUOTE ((LOOKUP CALLED)
(PARSE CALLED)))
COMPLEXITY:VECTOR (.3 .5 .5 .5 .1)
COMMENTS ((SETQ EV:NEW:INFO (EVAL NEW:INFO)))
IMPLICIT:ARGS (EV:NEW:INFO PART1 PART2))
(PUTPROPS USE:INFORMATION BEING T
IMPLICIT:ARGS (ACTION)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK EXECUTABLE:INFO:LIST
WHAT (TUPLE USE SOME AVAILABLE INFORMATION)
HOW (TUPLE PICK ONE OF (@ EXECUTABLE:INFO:LIST)
AND DO IT)
WHY (TUPLE IF WE DON'T DO WHAT WE CAN AS SOON AS POSSIBLE, WE MIGHT NEEDLESSLY BOTHER THE
USER, OUR SLOWEST CHANNNEL)
WHEN ((EXECUTABLE:INFO:LIST 120
(TUPLE BECAUSE WE COULD BE GOING IN CIRCLES IF WE DON'T DO WHAT
WE CAN AS SOON AS POSSIBLE)))
META:CODE (PROGN (SETQ ACTION (COND ((GETP (CAR (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))
NON:EVAL:ARGS)
(COND ((EQUAL (CAAR EXECUTABLE:INFO:LIST)
VECTOR)
(CDAR EXECUTABLE:INFO:LIST))
(T (CAR EXECUTABLE:INFO:LIST))))
(T (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))))
(SETQ EXECUTABLE:INFO:LIST (CDR EXECUTABLE:INFO:LIST))
(COND ((EVAL ACTION))
(T (NCONC1 EXECUTABLE:INFO:LIST ACTION)
NIL)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS UTILIZE BEING T
IDEN (((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI))))
IMPLICIT:ARGS (KNOW:LIST DEC)
EXPLICIT:ARGS (KNOW:NAME APPLIED:SO:AS:TO:KEEP INVARIANT)
EXPLICIT:ARGS:CHECK (AND (EQUAL (CAR INVARIANT)
VECTOR)
(MEMBER (CADR INVARIANT)
(QUOTE (RELEVANT IRRELEVANT)))
(ATOM KNOW:NAME)
(OR (NULL (EVAL KNOW:NAME))
(LISTP (EVAL KNOW:NAME))))
WHAT (TUPLE USE THE LIST (@ KNOW:LIST)
OF INFORMATION TO DECIDE THE TURNING POINT OF THE TRUTH OF THE PREDICATE (@ INVARIANT))
HOW (TUPLE SEARCH THROUGH (@ KNOW:LIST)
FOR APPLICABLE RULES)
WHY (TUPLE SO PUP KNOWS WHEN (@ INVARIANT)
CHANGES TRUTH VALUE)
META:CODE (PROG (AF HOLD:ANY2)
(COND ((MATCH (VECTOR ANY2 (VECTOR PUP REINVESTIGATE FRAG1))
INVARIANT)
(SETQ HOLD:ANY2 ANY2)
(SETQ DEC (CONS VECTOR FRAG1))
(COND ((AND (SETQ AF (CADR (MEMBER WHEN DEC)))
(MAPC (EVAL (COLON:BACK (CONS WHEN:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((AND (SETQ AF (CADR (MEMBER AFFECTS DEC)))
(MAPC (EVAL (COLON:BACK (CONS AFFECTS:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((MAPC KNOW:LIST (FUNCTION (LAMBDA (K)
(COND ((SETQ AF (EVAL K))
(RETURN (VECTOR
(OPPOSITE
HOLD:ANY2)
(@ AF)))))))))
(T (RETURN NIL))))
(T (RETURN NIL))))
COMMENTS ((OR (SETQ KNOW:LIST (EVAL KNOW:NAME))
T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS WHEN:NEXT BEING T
IDEN (((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI))))
IMPLICIT:ARGS (UTILIZATION UTIL2 AWARE:LIST)
EXPLICIT:ARGS (ACT)
EXPLICIT:ARGS:CHECK (AND (MEMBER (CADR ACT)
(QUOTE (USER PUP)))
(EQUAL (LENGTH ACT)
4))
WHAT (TUPLE FIND THE NEXT SITUATION IN WHICH (CADR ACT)
MUST PERFORM THE OPERATION (CADDR ACT)
ON
(CADDDR ACT))
HOW (TUPLE EXPLORE THE EFFECTS OF (CADDR ACT)
ING
(CADDDR ACT))
WHY (TUPLE (CADR ACT)
CAN THEN FORGET (CADDDR ACT)
UNTIL THE NEXT SITUATION WE FIND HERE)
MAIN:EFFECTS (((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2)))))
META:CODE (PROGN (SETQ RELEVANT:KNOWLEDGE (COLON:BACK (COPY (TUPLE (CADR (CADDDR ACT))
(CADR BEING:STACK)
KNOWLEDGE))))
(SETQ UTILIZATION (VECTOR DELAYABLE (@ ACT)
UNTIL
(SETQ UTIL2 (UTILIZE
RELEVANT:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
(VECTOR IRRELEVANT (APPEND
(VECTOR (CADR ACT)
(CADDR ACT))
(CDDAR (CDDDR ACT))))))))
(SETQ AWARE:LIST (COLON:BACK (COPY (LIST (QUOTE AWARE)
(CADR ACT)
(QUOTE LIST)))))
(SET AWARE:LIST (CONS UTILIZATION (EVAL AWARE:LIST)))
UTIL2)
COMPLEXITY:VECTOR (.6 .7 .5 .5 .1))
(PUTPROPS WRITE:PROGRAM IDEN (((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T))))
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES (@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE WRITTEN TO DO
(@ TASK)
IN ORDER THAT THE TASK (@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE SPEC:WHY)
WHEN ((T (COND ((MEMBER TASK ABLE:PUP:LIST)
-75)
(T 40))
(TUPLE BECAUSE A PRE:EXISTING ABILITY TO DO (@ TASK)
IMPLIES THAT WRITING A NEW PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
CONVERSELY, THE INABILITY TO DO (@ TASK)
ABDUCTIVELY ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
((MEMBER TASK WRITTEN:PROGRAMS:LIST)
-80
(QUOTE (BECAUSE WE ARE NOT AFTER MUCH EFFICIENCY, AND IF A PROGRAM ALREADY EXISTS,
THEN WE SHOULD USE IT)))
((MEMBER (TUPLE PUP IS ABOUT TO WRITE A PROGRAM TO DO (@ TASK))
AWARE:USER:LIST)
70
(QUOTE (BECAUSE WE GO BY THE OLD ENGLISH LEGAL RULE, THAT SILENCE SIGNIFIES APPROVAL)))
(T (COND (NEW:INFO:LIST -120)
(T 40))
(QUOTE (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE WRITING PROGRAMS ALSO:
BECAUSE IF NO NEW INFO IS PRESENT, THEN WE NEEDN'T FEEL GUILTY ABOUT
STARTING TO WRITE A PROGRAM))))
META:CODE (PROG (DONE PGM)
(SETQ PGM (VECTOR))
(SETQ UNDEFINED:SECTION:LIST (CONS (VECTOR (@ TASK:NAME)
TYPE OF (@ TASK))
UNDEFINED:SECTION:LIST))
LABEL4
(LONG:NAME:DEMON)
(COND ((MEMBER TASK:NAME WRITTEN:PROGRAMS:LIST)
(SETQ WRITTEN:PROGRAMS:LIST (CONS TASK WRITTEN:PROGRAMS:LIST))
(SETQ ABLE:PUP:LIST (CONS TASK ABLE:PUP:LIST))
(SETQ ABLE:USER:LIST (CONS TASK ABLE:USER:LIST))
(RETURN T))
((NOT (MEMBER NIL (MAPCAR (APPEND USER:INTERRUPT:DEMONS CURRENT:DEMONS)
(QUOTE APPLY*))))
(CHOOSE:FROM (QUOTE ((OBTAIN:USABLE:INFORMATION (QUOTE PGM))
(USE:INFORMATION (QUOTE PGM))
(FILL:IN:UNDEFINED:SECTION (QUOTE PGM))
(CLARIFY:IMPROBABLE:SITUATION (QUOTE PGM))
(ADAPT:PRECONCEIVED:FUNCTION (QUOTE PGM))
(FIX:INCORRECT:PIECE (QUOTE PGM)))))
(GO LABEL4))
(T (RETURN NIL))))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WRITE A PROGRAM TO DO
(@ TASK)))
(VECTOR NAMED EXPRESSION (@ TASK)
(VECTOR TASK:NAME))
(VECTOR AWARE USER (VECTOR THE NAME OF THE PROGRAM TO DO (@ TASK)
IS
(@ TASK:NAME)))
(VECTOR TYPE OF (VECTOR (@ TASK)
HAS BEEN STUDIED)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR THE PROGRAM (@ TASK:NAME)
TO DO (@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATION:DEMON)
MAIN:EFFECTS (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1))))
AFFECTS (QUOTE ((OBTAIN:USABLE:INFORMATION POSSIBLE:CALLED)
(USE:INFORMATION POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION POSSIBLE:CALLED)))
COMPLEXITY:VECTOR ((PLUS .3 (TIMES .6 (DIMENSION1 TASK:TYPE)))
.9 .7 .5 .1))
(MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(WIDEPAPER T)
(MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")
STOP